home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 26 / Cream of the Crop 26.iso / os2 / octa209s.zip / octave-2.09 / libs / readline / readline.c < prev    next >
C/C++ Source or Header  |  1996-11-06  |  84KB  |  3,582 lines
  1. /* Modified by Klaus Gebhardt, October 1996 */
  2. /* readline.c -- a general facility for reading lines of input
  3.    with emacs style editing and completion. */
  4.  
  5. /* Copyright (C) 1987, 1989, 1992 Free Software Foundation, Inc.
  6.  
  7.    This file is part of the GNU Readline Library, a library for
  8.    reading lines of text with interactive input and history editing.
  9.  
  10.    The GNU Readline Library is free software; you can redistribute it
  11.    and/or modify it under the terms of the GNU General Public License
  12.    as published by the Free Software Foundation; either version 1, or
  13.    (at your option) any later version.
  14.  
  15.    The GNU Readline Library is distributed in the hope that it will be
  16.    useful, but WITHOUT ANY WARRANTY; without even the implied warranty
  17.    of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18.    GNU General Public License for more details.
  19.  
  20.    The GNU General Public License is often shipped with GNU software, and
  21.    is generally kept in a file called COPYING or LICENSE.  If you do not
  22.    have a copy of the license, write to the Free Software Foundation,
  23.    675 Mass Ave, Cambridge, MA 02139, USA. */
  24.  
  25. #ifdef HAVE_CONFIG_H
  26. #include <config.h>
  27. #endif
  28.  
  29. #define READLINE_LIBRARY
  30.  
  31. #include <stdio.h>
  32. #include <sys/types.h>
  33. #include <fcntl.h>
  34. #if defined (HAVE_SYS_FILE)
  35. #  include <sys/file.h>
  36. #endif /* HAVE_SYS_FILE */
  37. #include <signal.h>
  38.  
  39. #if defined (HAVE_UNISTD_H)
  40. #  include <unistd.h>
  41. #endif /* HAVE_UNISTD_H */
  42.  
  43. #if defined (HAVE_STDLIB_H)
  44. #  include <stdlib.h>
  45. #else
  46. #  include "ansi_stdlib.h"
  47. #endif /* HAVE_STDLIB_H */
  48.  
  49. #include <errno.h>
  50. /* Not all systems declare ERRNO in errno.h... and some systems #define it! */
  51. #if !defined (errno)
  52. extern int errno;
  53. #endif /* !errno */
  54.  
  55. #include <setjmp.h>
  56.  
  57. #include "posixstat.h"
  58.  
  59. /* System-specific feature definitions and include files. */
  60. #include "rldefs.h"
  61.  
  62. #if defined (GWINSZ_IN_SYS_IOCTL) || (defined (VSTATUS) && !defined (SunOS4))
  63. #  include <sys/ioctl.h>
  64. #endif /* GWINSZ_IN_SYS_IOCTL || VSTATUS */
  65.  
  66. /* Some standard library routines. */
  67. #include "readline.h"
  68. #include "history.h"
  69.  
  70. #if defined (__EMX__) && defined (OS2)
  71. #include "cursor.h"      
  72. #endif
  73.  
  74. /* NOTE: Functions and variables prefixed with `_rl_' are
  75.    pseudo-global: they are global so they can be shared
  76.    between files in the readline library, but are not intended
  77.    to be visible to readline callers. */
  78.  
  79. /* Functions imported from other files in the library. */
  80. extern char *tgetstr ();
  81. extern void rl_prep_terminal (), rl_deprep_terminal ();
  82.  
  83. extern void _rl_bind_if_unbound ();
  84.  
  85. /* External redisplay functions and variables from display.c */
  86. extern void _rl_move_vert ();
  87. extern void _rl_update_final ();
  88.  
  89. extern void _rl_erase_at_end_of_line ();
  90. extern void _rl_move_cursor_relative ();
  91.  
  92. extern int _rl_vis_botlin;
  93. extern int _rl_last_c_pos;
  94. extern int _rl_horizontal_scroll_mode;
  95. extern int rl_display_fixed;
  96. extern char *rl_display_prompt;
  97.  
  98. /* Variables imported from complete.c. */
  99. extern char *rl_completer_word_break_characters;
  100. extern char *rl_basic_word_break_characters;
  101. extern int rl_completion_query_items;
  102. extern int rl_complete_with_tilde_expansion;
  103.  
  104. #if defined (VI_MODE)
  105. extern void _rl_vi_set_last ();
  106. extern void _rl_vi_reset_last ();
  107. extern void _rl_vi_done_inserting ();
  108. #endif /* VI_MODE */
  109.  
  110. /* Forward declarations used in this file. */
  111. void _rl_free_history_entry ();
  112.  
  113. int _rl_dispatch ();
  114. void _rl_set_screen_size ();
  115. int _rl_output_character_function ();
  116.  
  117. static char *readline_internal ();
  118. static void readline_initialize_everything ();
  119. static int init_terminal_io ();
  120. static void start_using_history ();
  121. static void bind_arrow_keys ();
  122.  
  123. #if !defined (__GO32__)
  124. static void readline_default_bindings ();
  125. #endif /* !__GO32__ */
  126.  
  127. #if defined (__GO32__)
  128. #  include <sys/pc.h>
  129. #  undef HANDLE_SIGNALS
  130. #endif /* __GO32__ */
  131.  
  132. #if defined (STATIC_MALLOC)
  133. static char *xmalloc (), *xrealloc ();
  134. #else
  135. extern char *xmalloc (), *xrealloc ();
  136. #endif /* STATIC_MALLOC */
  137.  
  138.  
  139. /* **************************************************************** */
  140. /*                                    */
  141. /*            Line editing input utility            */
  142. /*                                    */
  143. /* **************************************************************** */
  144.  
  145. static char *LibraryVersion = "2.0";
  146.  
  147. /* A pointer to the keymap that is currently in use.
  148.    By default, it is the standard emacs keymap. */
  149. Keymap _rl_keymap = emacs_standard_keymap;
  150.  
  151. /* The current style of editing. */
  152. int rl_editing_mode = emacs_mode;
  153.  
  154. /* Non-zero if the previous command was a kill command. */
  155. static int last_command_was_kill = 0;
  156.  
  157. /* The current value of the numeric argument specified by the user. */
  158. int rl_numeric_arg = 1;
  159.  
  160. /* Non-zero if an argument was typed. */
  161. int rl_explicit_arg = 0;
  162.  
  163. /* Temporary value used while generating the argument. */
  164. int rl_arg_sign = 1;
  165.  
  166. /* Non-zero means we have been called at least once before. */
  167. static int rl_initialized = 0;
  168.  
  169. /* If non-zero, this program is running in an EMACS buffer. */
  170. #ifdef __EMX__
  171. static char *running_in_emacs = (char *)NULL;
  172. #else
  173. static int running_in_emacs = 0;
  174. #endif
  175.  
  176. /* The current offset in the current input line. */
  177. int rl_point;
  178.  
  179. /* Mark in the current input line. */
  180. int rl_mark;
  181.  
  182. /* Length of the current input line. */
  183. int rl_end;
  184.  
  185. /* Make this non-zero to return the current input_line. */
  186. int rl_done;
  187.  
  188. /* The last function executed by readline. */
  189. Function *rl_last_func = (Function *)NULL;
  190.  
  191. /* Top level environment for readline_internal (). */
  192. static jmp_buf readline_top_level;
  193.  
  194. /* The streams we interact with. */
  195. static FILE *in_stream, *out_stream;
  196.  
  197. /* The names of the streams that we do input and output to. */
  198. FILE *rl_instream = (FILE *)NULL;
  199. FILE *rl_outstream = (FILE *)NULL;
  200.  
  201. /* Non-zero means echo characters as they are read. */
  202. int readline_echoing_p = 1;
  203.  
  204. /* Current prompt. */
  205. char *rl_prompt;
  206. int rl_visible_prompt_length = 0;
  207.  
  208. /* The number of characters read in order to type this complete command. */
  209. int rl_key_sequence_length = 0;
  210.  
  211. /* If non-zero, then this is the address of a function to call just
  212.    before readline_internal () prints the first prompt. */
  213. Function *rl_startup_hook = (Function *)NULL;
  214.  
  215. /* What we use internally.  You should always refer to RL_LINE_BUFFER. */
  216. static char *the_line;
  217.  
  218. /* The character that can generate an EOF.  Really read from
  219.    the terminal driver... just defaulted here. */
  220. int _rl_eof_char = CTRL ('D');
  221.  
  222. /* Non-zero makes this the next keystroke to read. */
  223. int rl_pending_input = 0;
  224.  
  225. /* Pointer to a useful terminal name. */
  226. char *rl_terminal_name = (char *)NULL;
  227.  
  228. /* Non-zero means to always use horizontal scrolling in line display. */
  229. int _rl_horizontal_scroll_mode = 0;
  230.  
  231. /* Non-zero means to display an asterisk at the starts of history lines
  232.    which have been modified. */
  233. int _rl_mark_modified_lines = 0;  
  234.  
  235. /* The style of `bell' notification preferred.  This can be set to NO_BELL,
  236.    AUDIBLE_BELL, or VISIBLE_BELL. */
  237. int _rl_bell_preference = AUDIBLE_BELL;
  238.      
  239. /* Line buffer and maintenence. */
  240. char *rl_line_buffer = (char *)NULL;
  241. int rl_line_buffer_len = 0;
  242. #define DEFAULT_BUFFER_SIZE 256
  243.  
  244. /* Forward declarations used by the display and termcap code. */
  245. int term_xn;
  246. int screenwidth, screenheight, screenchars;
  247.  
  248.  
  249. /* **************************************************************** */
  250. /*                                    */
  251. /*            `Forward' declarations              */
  252. /*                                    */
  253. /* **************************************************************** */
  254.  
  255. /* Non-zero means do not parse any lines other than comments and
  256.    parser directives. */
  257. unsigned char _rl_parsing_conditionalized_out = 0;
  258.  
  259. /* Non-zero means to save keys that we dispatch on in a kbd macro. */
  260. static int defining_kbd_macro = 0;
  261.  
  262. /* Non-zero means to convert characters with the meta bit set to
  263.    escape-prefixed characters so we can indirect through
  264.    emacs_meta_keymap or vi_escape_keymap. */
  265. int _rl_convert_meta_chars_to_ascii = 1;
  266.  
  267. /* Non-zero means to output characters with the meta bit set directly
  268.    rather than as a meta-prefixed escape sequence. */
  269. int _rl_output_meta_chars = 0;
  270.  
  271. /* Non-zero tells rl_delete_text and rl_insert_text to not add to
  272.    the undo list. */
  273. static int doing_an_undo = 0;
  274.  
  275. /* **************************************************************** */
  276. /*                                    */
  277. /*            Top Level Functions                */
  278. /*                                    */
  279. /* **************************************************************** */
  280.  
  281. /* Non-zero means treat 0200 bit in terminal input as Meta bit. */
  282. int _rl_meta_flag = 0;    /* Forward declaration */
  283.  
  284. /* Read a line of input.  Prompt with PROMPT.  A NULL PROMPT means
  285.    none.  A return value of NULL means that EOF was encountered. */
  286. char *
  287. readline (prompt)
  288.      char *prompt;
  289. {
  290.   char *value;
  291.  
  292.   rl_prompt = prompt;
  293.  
  294.   /* If we are at EOF return a NULL string. */
  295.   if (rl_pending_input == EOF)
  296.     {
  297.       rl_pending_input = 0;
  298.       return ((char *)NULL);
  299.     }
  300.  
  301.   rl_visible_prompt_length = rl_expand_prompt (rl_prompt);
  302.  
  303.   rl_initialize ();
  304.   rl_prep_terminal (_rl_meta_flag);
  305.  
  306. #if defined (HANDLE_SIGNALS)
  307.   rl_set_signals ();
  308. #endif
  309.  
  310.   value = readline_internal ();
  311.   rl_deprep_terminal ();
  312.  
  313. #if defined (HANDLE_SIGNALS)
  314.   rl_clear_signals ();
  315. #endif
  316.  
  317.   return (value);
  318. }
  319.  
  320. /* Read a line of input from the global rl_instream, doing output on
  321.    the global rl_outstream.
  322.    If rl_prompt is non-null, then that is our prompt. */
  323. static char *
  324. readline_internal ()
  325. {
  326.   int lastc, c, eof_found;
  327.  
  328.   in_stream  = rl_instream;
  329.   out_stream = rl_outstream;
  330.  
  331.   lastc = -1;
  332.   eof_found = 0;
  333.  
  334.   if (rl_startup_hook)
  335.     (*rl_startup_hook) ();
  336.  
  337.   if (!readline_echoing_p)
  338.     {
  339.       if (rl_prompt)
  340.     {
  341.       fprintf (out_stream, "%s", rl_prompt);
  342.       fflush (out_stream);
  343.     }
  344.     }
  345.   else
  346.     {
  347.       rl_on_new_line ();
  348.       rl_redisplay ();
  349. #if defined (VI_MODE)
  350.       if (rl_editing_mode == vi_mode)
  351.     rl_vi_insertion_mode ();
  352. #endif /* VI_MODE */
  353.     }
  354.  
  355.   while (!rl_done)
  356.     {
  357.       int lk = last_command_was_kill;
  358.       int code;
  359.  
  360.       code = setjmp (readline_top_level);
  361.  
  362.       if (code)
  363.     rl_redisplay ();
  364.  
  365.       if (!rl_pending_input)
  366.     {
  367.       /* Then initialize the argument and number of keys read. */
  368.       rl_init_argument ();
  369.       rl_key_sequence_length = 0;
  370.     }
  371.  
  372.       c = rl_read_key ();
  373.  
  374.       /* EOF typed to a non-blank line is a <NL>. */
  375.       if (c == EOF && rl_end)
  376.     c = NEWLINE;
  377.  
  378.       /* The character _rl_eof_char typed to blank line, and not as the
  379.      previous character is interpreted as EOF. */
  380.       if (((c == _rl_eof_char && lastc != c) || c == EOF) && !rl_end)
  381.     {
  382.       eof_found = 1;
  383.       break;
  384.     }
  385.  
  386.       lastc = c;
  387.       _rl_dispatch (c, _rl_keymap);
  388.  
  389.       /* If there was no change in last_command_was_kill, then no kill
  390.      has taken place.  Note that if input is pending we are reading
  391.      a prefix command, so nothing has changed yet. */
  392.       if (!rl_pending_input)
  393.     {
  394.       if (lk == last_command_was_kill)
  395.         last_command_was_kill = 0;
  396.     }
  397.  
  398. #if defined (VI_MODE)
  399.       /* In vi mode, when you exit insert mode, the cursor moves back
  400.      over the previous character.  We explicitly check for that here. */
  401.       if (rl_editing_mode == vi_mode && _rl_keymap == vi_movement_keymap)
  402.     rl_vi_check ();
  403. #endif /* VI_MODE */
  404.  
  405.       if (!rl_done)
  406.     rl_redisplay ();
  407.     }
  408.  
  409.   /* Restore the original of this history line, iff the line that we
  410.      are editing was originally in the history, AND the line has changed. */
  411.   {
  412.     HIST_ENTRY *entry = current_history ();
  413.  
  414.     if (entry && rl_undo_list)
  415.       {
  416.     char *temp = savestring (the_line);
  417.     rl_revert_line ();
  418.     entry = replace_history_entry (where_history (), the_line,
  419.                        (HIST_ENTRY *)NULL);
  420.     _rl_free_history_entry (entry);
  421.  
  422.     strcpy (the_line, temp);
  423.     free (temp);
  424.       }
  425.   }
  426.  
  427.   /* At any rate, it is highly likely that this line has an undo list.  Get
  428.      rid of it now. */
  429.   if (rl_undo_list)
  430.     free_undo_list ();
  431.  
  432.   if (eof_found)
  433.     return (char *)NULL;
  434.   else
  435.     return (savestring (the_line));
  436. }
  437.  
  438. /* **************************************************************** */
  439. /*                                    */
  440. /*            Character Input Buffering               */
  441. /*                                    */
  442. /* **************************************************************** */
  443.  
  444. static int pop_index = 0, push_index = 0, ibuffer_len = 511;
  445. static unsigned char ibuffer[512];
  446.  
  447. /* Non-null means it is a pointer to a function to run while waiting for
  448.    character input. */
  449. Function *rl_event_hook = (Function *)NULL;
  450.  
  451. #define any_typein (push_index != pop_index)
  452.  
  453. /* Add KEY to the buffer of characters to be read. */
  454. rl_stuff_char (key)
  455.      int key;
  456. {
  457.   if (key == EOF)
  458.     {
  459.       key = NEWLINE;
  460.       rl_pending_input = EOF;
  461.     }
  462.   ibuffer[push_index++] = key;
  463.   if (push_index >= ibuffer_len)
  464.     push_index = 0;
  465.   return push_index;
  466. }
  467.  
  468. /* Return the amount of space available in the
  469.    buffer for stuffing characters. */
  470. int
  471. ibuffer_space ()
  472. {
  473.   if (pop_index > push_index)
  474.     return (pop_index - push_index);
  475.   else
  476.     return (ibuffer_len - (push_index - pop_index));
  477. }
  478.  
  479. /* Get a key from the buffer of characters to be read.
  480.    Return the key in KEY.
  481.    Result is KEY if there was a key, or 0 if there wasn't. */
  482. int
  483. rl_get_char (key)
  484.      int *key;
  485. {
  486.   if (push_index == pop_index)
  487.     return (0);
  488.  
  489.   *key = ibuffer[pop_index++];
  490.  
  491.   if (pop_index >= ibuffer_len)
  492.     pop_index = 0;
  493.  
  494.   return (1);
  495. }
  496.  
  497. /* Stuff KEY into the *front* of the input buffer.
  498.    Returns non-zero if successful, zero if there is
  499.    no space left in the buffer. */
  500. int
  501. rl_unget_char (key)
  502.      int key;
  503. {
  504.   if (ibuffer_space ())
  505.     {
  506.       pop_index--;
  507.       if (pop_index < 0)
  508.     pop_index = ibuffer_len - 1;
  509.       ibuffer[pop_index] = key;
  510.       return (1);
  511.     }
  512.   return (0);
  513. }
  514.  
  515. /* If a character is available to be read, then read it
  516.    and stuff it into IBUFFER.  Otherwise, just return. */
  517. void
  518. rl_gather_tyi ()
  519. {
  520. #if defined (__GO32__)
  521.   char input;
  522.  
  523.   if (isatty (0))
  524.     {
  525.       int i = rl_getc ();
  526.  
  527.       if (i != EOF)
  528.     rl_stuff_char (i);
  529.     }
  530.   else if (kbhit () && ibuffer_space ())
  531.     rl_stuff_char (getkey ());
  532. #else /* !__GO32__ */
  533.  
  534.   int tty = fileno (in_stream);
  535.   register int tem, result = -1;
  536.   int chars_avail;
  537.   char input;
  538.  
  539. #if defined (FIONREAD)
  540.   result = ioctl (tty, FIONREAD, &chars_avail);
  541. #endif
  542.  
  543. #if defined (O_NDELAY)
  544.   if (result == -1)
  545.     {
  546.       int flags;
  547.  
  548.       flags = fcntl (tty, F_GETFL, 0);
  549.  
  550.       fcntl (tty, F_SETFL, (flags | O_NDELAY));
  551.       chars_avail = read (tty, &input, 1);
  552.  
  553.       fcntl (tty, F_SETFL, flags);
  554.       if (chars_avail == -1 && errno == EAGAIN)
  555.     return;
  556.     }
  557. #endif /* O_NDELAY */
  558.  
  559.   /* If there's nothing available, don't waste time trying to read
  560.      something. */
  561.   if (chars_avail == 0)
  562.     return;
  563.  
  564.   tem = ibuffer_space ();
  565.  
  566.   if (chars_avail > tem)
  567.     chars_avail = tem;
  568.  
  569.   /* One cannot read all of the available input.  I can only read a single
  570.      character at a time, or else programs which require input can be
  571.      thwarted.  If the buffer is larger than one character, I lose.
  572.      Damn! */
  573.   if (tem < ibuffer_len)
  574.     chars_avail = 0;
  575.  
  576.   if (result != -1)
  577.     {
  578.       while (chars_avail--)
  579.     rl_stuff_char (rl_getc (in_stream));
  580.     }
  581.   else
  582.     {
  583.       if (chars_avail)
  584.     rl_stuff_char (input);
  585.     }
  586. #endif /* !__GO32__ */
  587. }
  588.  
  589. static int next_macro_key ();
  590. /* Read a key, including pending input. */
  591. int
  592. rl_read_key ()
  593. {
  594.   int c;
  595.  
  596.   rl_key_sequence_length++;
  597.  
  598.   if (rl_pending_input)
  599.     {
  600.       c = rl_pending_input;
  601.       rl_pending_input = 0;
  602.     }
  603.   else
  604.     {
  605.       /* If input is coming from a macro, then use that. */
  606.       if (c = next_macro_key ())
  607.     return (c);
  608.  
  609.       /* If the user has an event function, then call it periodically. */
  610.       if (rl_event_hook)
  611.     {
  612.       while (rl_event_hook && !rl_get_char (&c))
  613.         {
  614.           (*rl_event_hook) ();
  615.           rl_gather_tyi ();
  616.         }
  617.     }
  618.       else
  619.     {
  620.       if (!rl_get_char (&c))
  621.         c = rl_getc (in_stream);
  622.     }
  623.     }
  624.  
  625.   return (c);
  626. }
  627.  
  628. /* Found later in this file. */
  629. static void add_macro_char (), with_macro_input ();
  630.  
  631. /* Do the command associated with KEY in MAP.
  632.    If the associated command is really a keymap, then read
  633.    another key, and dispatch into that map. */
  634. int
  635. _rl_dispatch (key, map)
  636.      register int key;
  637.      Keymap map;
  638. {
  639.   int r = 0;
  640.  
  641.   if (META_CHAR (key) && _rl_convert_meta_chars_to_ascii)
  642.     {
  643.       if (map[ESC].type == ISKMAP)
  644.     {
  645.       if (defining_kbd_macro)
  646.         add_macro_char (ESC);
  647.       map = FUNCTION_TO_KEYMAP (map, ESC);
  648.       key = UNMETA (key);
  649.       rl_key_sequence_length += 2;
  650.       return (_rl_dispatch (key, map));
  651.     }
  652.       else
  653.     ding ();
  654.       return 0;
  655.     }
  656.  
  657.   if (defining_kbd_macro)
  658.     add_macro_char (key);
  659.  
  660.   switch (map[key].type)
  661.     {
  662.     case ISFUNC:
  663.       {
  664.     Function *func = map[key].function;
  665.  
  666.     if (func != (Function *)NULL)
  667.       {
  668.         /* Special case rl_do_lowercase_version (). */
  669.         if (func == rl_do_lowercase_version)
  670.           return (_rl_dispatch (to_lower (key), map));
  671.  
  672.         r = (*map[key].function)(rl_numeric_arg * rl_arg_sign, key);
  673.  
  674.         /* If we have input pending, then the last command was a prefix
  675.            command.  Don't change the state of rl_last_func.  Otherwise,
  676.            remember the last command executed in this variable. */
  677.         if (!rl_pending_input)
  678.           rl_last_func = map[key].function;
  679.       }
  680.     else
  681.       {
  682.         rl_abort ();
  683.         return -1;
  684.       }
  685.       }
  686.       break;
  687.  
  688.     case ISKMAP:
  689.       if (map[key].function != (Function *)NULL)
  690.     {
  691.       int newkey;
  692.  
  693.       rl_key_sequence_length++;
  694.       newkey = rl_read_key ();
  695.       r = _rl_dispatch (newkey, FUNCTION_TO_KEYMAP (map, key));
  696.     }
  697.       else
  698.     {
  699.       rl_abort ();
  700.       return -1;
  701.     }
  702.       break;
  703.  
  704.     case ISMACR:
  705.       if (map[key].function != (Function *)NULL)
  706.     {
  707.       char *macro;
  708.  
  709.       macro = savestring ((char *)map[key].function);
  710.       with_macro_input (macro);
  711.       return 0;
  712.     }
  713.       break;
  714.     }
  715. #if defined (VI_MODE)
  716.   if (rl_editing_mode == vi_mode && _rl_keymap == vi_movement_keymap &&
  717.       rl_vi_textmod_command (key))
  718.     _rl_vi_set_last (key, rl_numeric_arg, rl_arg_sign);
  719. #endif
  720.   return (r);
  721. }
  722.  
  723.  
  724. /* **************************************************************** */
  725. /*                                    */
  726. /*            Hacking Keyboard Macros             */
  727. /*                                    */
  728. /* **************************************************************** */
  729.  
  730. /* The currently executing macro string.  If this is non-zero,
  731.    then it is a malloc ()'ed string where input is coming from. */
  732. static char *executing_macro = (char *)NULL;
  733.  
  734. /* The offset in the above string to the next character to be read. */
  735. static int executing_macro_index = 0;
  736.  
  737. /* The current macro string being built.  Characters get stuffed
  738.    in here by add_macro_char (). */
  739. static char *current_macro = (char *)NULL;
  740.  
  741. /* The size of the buffer allocated to current_macro. */
  742. static int current_macro_size = 0;
  743.  
  744. /* The index at which characters are being added to current_macro. */
  745. static int current_macro_index = 0;
  746.  
  747. /* A structure used to save nested macro strings.
  748.    It is a linked list of string/index for each saved macro. */
  749. struct saved_macro {
  750.   struct saved_macro *next;
  751.   char *string;
  752.   int sindex;
  753. };
  754.  
  755. /* The list of saved macros. */
  756. struct saved_macro *macro_list = (struct saved_macro *)NULL;
  757.  
  758. /* Forward declarations of static functions.  Thank you C. */
  759. static void push_executing_macro (), pop_executing_macro ();
  760.  
  761. /* This one has to be declared earlier in the file. */
  762. /* static void add_macro_char (); */
  763.  
  764. /* Set up to read subsequent input from STRING.
  765.    STRING is free ()'ed when we are done with it. */
  766. static void
  767. with_macro_input (string)
  768.      char *string;
  769. {
  770.   push_executing_macro ();
  771.   executing_macro = string;
  772.   executing_macro_index = 0;
  773. }
  774.  
  775. /* Return the next character available from a macro, or 0 if
  776.    there are no macro characters. */
  777. static int
  778. next_macro_key ()
  779. {
  780.   if (!executing_macro)
  781.     return (0);
  782.  
  783.   if (!executing_macro[executing_macro_index])
  784.     {
  785.       pop_executing_macro ();
  786.       return (next_macro_key ());
  787.     }
  788.  
  789.   return (executing_macro[executing_macro_index++]);
  790. }
  791.  
  792. /* Save the currently executing macro on a stack of saved macros. */
  793. static void
  794. push_executing_macro ()
  795. {
  796.   struct saved_macro *saver;
  797.  
  798.   saver = (struct saved_macro *)xmalloc (sizeof (struct saved_macro));
  799.   saver->next = macro_list;
  800.   saver->sindex = executing_macro_index;
  801.   saver->string = executing_macro;
  802.  
  803.   macro_list = saver;
  804. }
  805.  
  806. /* Discard the current macro, replacing it with the one
  807.    on the top of the stack of saved macros. */
  808. static void
  809. pop_executing_macro ()
  810. {
  811.   if (executing_macro)
  812.     free (executing_macro);
  813.  
  814.   executing_macro = (char *)NULL;
  815.   executing_macro_index = 0;
  816.  
  817.   if (macro_list)
  818.     {
  819.       struct saved_macro *disposer = macro_list;
  820.       executing_macro = macro_list->string;
  821.       executing_macro_index = macro_list->sindex;
  822.       macro_list = macro_list->next;
  823.       free (disposer);
  824.     }
  825. }
  826.  
  827. /* Add a character to the macro being built. */
  828. static void
  829. add_macro_char (c)
  830.      int c;
  831. {
  832.   if (current_macro_index + 1 >= current_macro_size)
  833.     {
  834.       if (!current_macro)
  835.     current_macro = xmalloc (current_macro_size = 25);
  836.       else
  837.     current_macro = xrealloc (current_macro, current_macro_size += 25);
  838.     }
  839.  
  840.   current_macro[current_macro_index++] = c;
  841.   current_macro[current_macro_index] = '\0';
  842. }
  843.  
  844. /* Begin defining a keyboard macro.
  845.    Keystrokes are recorded as they are executed.
  846.    End the definition with rl_end_kbd_macro ().
  847.    If a numeric argument was explicitly typed, then append this
  848.    definition to the end of the existing macro, and start by
  849.    re-executing the existing macro. */
  850. rl_start_kbd_macro (ignore1, ignore2)
  851.      int ignore1, ignore2;
  852. {
  853.   if (defining_kbd_macro)
  854.     {
  855.       rl_abort ();
  856.       return -1;
  857.     }
  858.  
  859.   if (rl_explicit_arg)
  860.     {
  861.       if (current_macro)
  862.     with_macro_input (savestring (current_macro));
  863.     }
  864.   else
  865.     current_macro_index = 0;
  866.  
  867.   defining_kbd_macro = 1;
  868.   return 0;
  869. }
  870.  
  871. /* Stop defining a keyboard macro.
  872.    A numeric argument says to execute the macro right now,
  873.    that many times, counting the definition as the first time. */
  874. rl_end_kbd_macro (count, ignore)
  875.      int count, ignore;
  876. {
  877.   if (!defining_kbd_macro)
  878.     {
  879.       rl_abort ();
  880.       return -1;
  881.     }
  882.  
  883.   current_macro_index -= (rl_key_sequence_length - 1);
  884.   current_macro[current_macro_index] = '\0';
  885.  
  886.   defining_kbd_macro = 0;
  887.  
  888.   return (rl_call_last_kbd_macro (--count, 0));
  889. }
  890.  
  891. /* Execute the most recently defined keyboard macro.
  892.    COUNT says how many times to execute it. */
  893. rl_call_last_kbd_macro (count, ignore)
  894.      int count, ignore;
  895. {
  896.   if (!current_macro)
  897.     rl_abort ();
  898.  
  899.   if (defining_kbd_macro)
  900.     {
  901.       ding ();        /* no recursive macros */
  902.       current_macro[--current_macro_index] = '\0';    /* erase this char */
  903.       return 0;
  904.     }
  905.  
  906.   while (count--)
  907.     with_macro_input (savestring (current_macro));
  908.   return 0;
  909. }
  910.  
  911. void
  912. _rl_kill_kbd_macro ()
  913. {
  914.   if (current_macro)
  915.     {
  916.       free (current_macro);
  917.       current_macro = (char *) NULL;
  918.     }
  919.   current_macro_size = current_macro_index = 0;
  920.  
  921.   if (executing_macro)
  922.     {
  923.       free (executing_macro);
  924.       executing_macro = (char *) NULL;
  925.     }
  926.   executing_macro_index = 0;
  927.  
  928.   defining_kbd_macro = 0;
  929. }
  930.  
  931. /* **************************************************************** */
  932. /*                                    */
  933. /*            Initializations                 */
  934. /*                                    */
  935. /* **************************************************************** */
  936.  
  937. /* Initliaze readline (and terminal if not already). */
  938. rl_initialize ()
  939. {
  940.   /* If we have never been called before, initialize the
  941.      terminal and data structures. */
  942.   if (!rl_initialized)
  943.     {
  944. #if defined (__EMX__) && defined (OS2)
  945.       _setcursortype (2);
  946. #endif
  947.  
  948.       readline_initialize_everything ();
  949.       rl_initialized++;
  950.     }
  951.  
  952.   /* Initalize the current line information. */
  953.   rl_point = rl_end = 0;
  954.   the_line = rl_line_buffer;
  955.   the_line[0] = 0;
  956.  
  957.   /* We aren't done yet.  We haven't even gotten started yet! */
  958.   rl_done = 0;
  959.  
  960.   /* Tell the history routines what is going on. */
  961.   start_using_history ();
  962.  
  963.   /* Make the display buffer match the state of the line. */
  964.   rl_reset_line_state ();
  965.  
  966.   /* No such function typed yet. */
  967.   rl_last_func = (Function *)NULL;
  968.  
  969.   /* Parsing of key-bindings begins in an enabled state. */
  970.   _rl_parsing_conditionalized_out = 0;
  971.  
  972.   return 0;
  973. }
  974.  
  975. /* Initialize the entire state of the world. */
  976. static void
  977. readline_initialize_everything ()
  978. {
  979.   char *t;
  980.  
  981.   /* Find out if we are running in Emacs. */
  982. #ifdef __EMX__
  983.   running_in_emacs = getenv ("EMACS");
  984. #else
  985.   running_in_emacs = getenv ("EMACS") != (char *)0;
  986. #endif
  987.  
  988.   /* Set up input and output if they are not already set up. */
  989.   if (!rl_instream)
  990.     rl_instream = stdin;
  991.  
  992.   if (!rl_outstream)
  993.     rl_outstream = stdout;
  994.  
  995.   /* Bind in_stream and out_stream immediately.  These values may change,
  996.      but they may also be used before readline_internal () is called. */
  997.   in_stream = rl_instream;
  998.   out_stream = rl_outstream;
  999.  
  1000.   /* Allocate data structures. */
  1001.   if (!rl_line_buffer)
  1002.     rl_line_buffer = xmalloc (rl_line_buffer_len = DEFAULT_BUFFER_SIZE);
  1003.  
  1004.   /* Initialize the terminal interface. */
  1005.   init_terminal_io ((char *)NULL);
  1006.  
  1007. #if !defined (__GO32__)
  1008.   /* Bind tty characters to readline functions. */
  1009.   readline_default_bindings ();
  1010. #endif /* !__GO32__ */
  1011.  
  1012.   /* Initialize the function names. */
  1013.   rl_initialize_funmap ();
  1014.  
  1015.   /* Check for LC_CTYPE and use its value to decide the defaults for
  1016.      8-bit character input and output. */
  1017.   t = getenv ("LC_CTYPE");
  1018.   if (t && (strcmp (t, "iso-8859-1") == 0 || strcmp (t, "iso_8859_1") == 0 ||
  1019.           strcmp (t, "ISO-8859-1") == 0))
  1020.     {
  1021.       _rl_meta_flag = 1;
  1022.       _rl_convert_meta_chars_to_ascii = 0;
  1023.       _rl_output_meta_chars = 1;
  1024.     }
  1025.       
  1026.   /* Read in the init file. */
  1027.   rl_read_init_file ((char *)NULL);
  1028.  
  1029.   /* XXX */
  1030.   if (_rl_horizontal_scroll_mode && term_xn)
  1031.     {
  1032.       screenwidth--;
  1033.       screenchars -= screenheight;
  1034.     }
  1035.  
  1036.   /* Override the effect of any `set keymap' assignments in the
  1037.      inputrc file. */
  1038.   rl_set_keymap_from_edit_mode ();
  1039.  
  1040.   /* Try to bind a common arrow key prefix, if not already bound. */
  1041.   bind_arrow_keys ();
  1042.  
  1043.   /* If the completion parser's default word break characters haven't
  1044.      been set yet, then do so now. */
  1045.   if (rl_completer_word_break_characters == (char *)NULL)
  1046.     rl_completer_word_break_characters = rl_basic_word_break_characters;
  1047. }
  1048.  
  1049. /* If this system allows us to look at the values of the regular
  1050.    input editing characters, then bind them to their readline
  1051.    equivalents, iff the characters are not bound to keymaps. */
  1052. static void
  1053. readline_default_bindings ()
  1054. {
  1055.   rltty_set_default_bindings (_rl_keymap);
  1056. }
  1057.  
  1058. static void
  1059. bind_arrow_keys_internal ()
  1060. {
  1061.   Function *f;
  1062.  
  1063.   f = rl_function_of_keyseq ("\033[A", _rl_keymap, (int *)NULL);
  1064.   if (!f || f == rl_do_lowercase_version)
  1065.     {
  1066.       _rl_bind_if_unbound ("\033[A", rl_get_previous_history);
  1067.       _rl_bind_if_unbound ("\033[B", rl_get_next_history);
  1068.       _rl_bind_if_unbound ("\033[C", rl_forward);
  1069.       _rl_bind_if_unbound ("\033[D", rl_backward);
  1070.     }
  1071.  
  1072.   f = rl_function_of_keyseq ("\033OA", _rl_keymap, (int *)NULL);
  1073.   if (!f || f == rl_do_lowercase_version)
  1074.     {
  1075.       _rl_bind_if_unbound ("\033OA", rl_get_previous_history);
  1076.       _rl_bind_if_unbound ("\033OB", rl_get_next_history);
  1077.       _rl_bind_if_unbound ("\033OC", rl_forward);
  1078.       _rl_bind_if_unbound ("\033OD", rl_backward);
  1079.     }
  1080. }
  1081.  
  1082. /* Try and bind the common arrow key prefix after giving termcap and
  1083.    the inputrc file a chance to bind them and create `real' keymaps
  1084.    for the arrow key prefix. */
  1085. static void
  1086. bind_arrow_keys ()
  1087. {
  1088.   Keymap xkeymap;
  1089.  
  1090.   xkeymap = _rl_keymap;
  1091.  
  1092.   _rl_keymap = emacs_standard_keymap;
  1093.   bind_arrow_keys_internal ();
  1094.  
  1095. #if defined (VI_MODE)
  1096.   _rl_keymap = vi_movement_keymap;
  1097.   bind_arrow_keys_internal ();
  1098. #endif
  1099.  
  1100.   _rl_keymap = xkeymap;
  1101. }
  1102.  
  1103.  
  1104. /* **************************************************************** */
  1105. /*                                    */
  1106. /*            Numeric Arguments                */
  1107. /*                                    */
  1108. /* **************************************************************** */
  1109.  
  1110. /* Handle C-u style numeric args, as well as M--, and M-digits. */
  1111. static int
  1112. rl_digit_loop ()
  1113. {
  1114.   int key, c;
  1115.  
  1116.   while (1)
  1117.     {
  1118.       rl_message ("(arg: %d) ", rl_arg_sign * rl_numeric_arg);
  1119.       key = c = rl_read_key ();
  1120.  
  1121.       if (_rl_keymap[c].type == ISFUNC &&
  1122.       _rl_keymap[c].function == rl_universal_argument)
  1123.     {
  1124.       rl_numeric_arg *= 4;
  1125.       continue;
  1126.     }
  1127.       c = UNMETA (c);
  1128.       if (digit_p (c))
  1129.     {
  1130.       if (rl_explicit_arg)
  1131.         rl_numeric_arg = (rl_numeric_arg * 10) + (c - '0');
  1132.       else
  1133.         rl_numeric_arg = (c - '0');
  1134.       rl_explicit_arg = 1;
  1135.     }
  1136.       else
  1137.     {
  1138.       if (c == '-' && !rl_explicit_arg)
  1139.         {
  1140.           rl_numeric_arg = 1;
  1141.           rl_arg_sign = -1;
  1142.         }
  1143.       else
  1144.         {
  1145.           rl_clear_message ();
  1146.           return (_rl_dispatch (key, _rl_keymap));
  1147.         }
  1148.     }
  1149.     }
  1150.   return 0;
  1151. }
  1152.  
  1153. /* Add the current digit to the argument in progress. */
  1154. rl_digit_argument (ignore, key)
  1155.      int ignore, key;
  1156. {
  1157.   rl_pending_input = key;
  1158.   return (rl_digit_loop ());
  1159. }
  1160.  
  1161. /* What to do when you abort reading an argument. */
  1162. rl_discard_argument ()
  1163. {
  1164.   ding ();
  1165.   rl_clear_message ();
  1166.   rl_init_argument ();
  1167.   return 0;
  1168. }
  1169.  
  1170. /* Create a default argument. */
  1171. rl_init_argument ()
  1172. {
  1173.   rl_numeric_arg = rl_arg_sign = 1;
  1174.   rl_explicit_arg = 0;
  1175.   return 0;
  1176. }
  1177.  
  1178. /* C-u, universal argument.  Multiply the current argument by 4.
  1179.    Read a key.  If the key has nothing to do with arguments, then
  1180.    dispatch on it.  If the key is the abort character then abort. */
  1181. rl_universal_argument ()
  1182. {
  1183.   rl_numeric_arg *= 4;
  1184.   return (rl_digit_loop ());
  1185. }
  1186.  
  1187. /* **************************************************************** */
  1188. /*                                    */
  1189. /*            Terminal and Termcap                */
  1190. /*                                    */
  1191. /* **************************************************************** */
  1192.  
  1193. static char *term_buffer = (char *)NULL;
  1194. static char *term_string_buffer = (char *)NULL;
  1195.  
  1196. static int tcap_initialized = 0;
  1197.  
  1198. /* Non-zero means this terminal can't really do anything. */
  1199. int dumb_term = 0;
  1200. /* On Solaris2, sys/types.h #includes sys/reg.h, which #defines PC.
  1201.    Unfortunately, PC is a global variable used by the termcap library. */
  1202. #undef PC
  1203.  
  1204. #if !defined (__linux__)
  1205. /* If this causes problems, add back the `extern'. */
  1206. /*extern*/ char PC, *BC, *UP;
  1207. #endif /* __linux__ */
  1208.  
  1209. /* Some strings to control terminal actions.  These are output by tputs (). */
  1210. char *term_goto, *term_clreol, *term_cr, *term_clrpag, *term_backspace;
  1211. char *term_pc;
  1212.  
  1213. /* Non-zero if we determine that the terminal can do character insertion. */
  1214. int terminal_can_insert = 0;
  1215.  
  1216. /* How to insert characters. */
  1217. char *term_im, *term_ei, *term_ic, *term_ip, *term_IC;
  1218.  
  1219. /* How to delete characters. */
  1220. char *term_dc, *term_DC;
  1221.  
  1222. #if defined (HACK_TERMCAP_MOTION)
  1223. char *term_forward_char;
  1224. #endif  /* HACK_TERMCAP_MOTION */
  1225.  
  1226. /* How to go up a line. */
  1227. char *term_up;
  1228.  
  1229. /* A visible bell, if the terminal can be made to flash the screen. */
  1230. char *visible_bell;
  1231.  
  1232. /* Non-zero means that this terminal has a meta key. */
  1233. int term_has_meta;
  1234.  
  1235. /* The string to write to turn on the meta key, if this term has one. */
  1236. char *term_mm;
  1237.  
  1238. /* The string to write to turn off the meta key, if this term has one. */
  1239. char *term_mo;
  1240.  
  1241. /* The key sequences output by the arrow keys, if this terminal has any. */
  1242. char *term_ku, *term_kd, *term_kr, *term_kl;
  1243.  
  1244. /* How to initialize and reset the arrow keys, if this terminal has any. */
  1245. char *term_ks, *term_ke;
  1246.  
  1247. /* Re-initialize the terminal considering that the TERM/TERMCAP variable
  1248.    has changed. */
  1249. rl_reset_terminal (terminal_name)
  1250.      char *terminal_name;
  1251. {
  1252.   init_terminal_io (terminal_name);
  1253.   return 0;
  1254. }
  1255.  
  1256. /* Set readline's idea of the screen size.  TTY is a file descriptor open
  1257.    to the terminal.  If IGNORE_ENV is true, we do not pay attention to the
  1258.    values of $LINES and $COLUMNS.  The tests for TERM_STRING_BUFFER being
  1259.    non-null serve to check whether or not we have initialized termcap. */
  1260. void
  1261. _rl_set_screen_size (tty, ignore_env)
  1262.      int tty, ignore_env;
  1263. {
  1264. #if defined (TIOCGWINSZ)
  1265.   struct winsize window_size;
  1266. #endif /* TIOCGWINSZ */
  1267.  
  1268. #if defined (TIOCGWINSZ)
  1269.   if (ioctl (tty, TIOCGWINSZ, &window_size) == 0)
  1270.     {
  1271.       screenwidth = (int) window_size.ws_col;
  1272.       screenheight = (int) window_size.ws_row;
  1273.     }
  1274. #endif /* TIOCGWINSZ */
  1275.  
  1276. #if defined (__EMX__)
  1277.   {
  1278.     int size[2];
  1279.  
  1280.     _scrsize (size);
  1281.     screenwidth = size[0]; screenheight = size[1];
  1282.   }
  1283. #endif
  1284.  
  1285.   /* Environment variable COLUMNS overrides setting of "co" if IGNORE_ENV
  1286.      is unset. */
  1287.   if (screenwidth <= 0)
  1288.     {
  1289.       char *sw;
  1290.  
  1291.       if (!ignore_env && (sw = getenv ("COLUMNS")))
  1292.     screenwidth = atoi (sw);
  1293.  
  1294.       if (screenwidth <= 0 && term_string_buffer)
  1295.     screenwidth = tgetnum ("co");
  1296.     }
  1297.  
  1298.   /* Environment variable LINES overrides setting of "li" if IGNORE_ENV
  1299.      is unset. */
  1300.   if (screenheight <= 0)
  1301.     {
  1302.       char *sh;
  1303.  
  1304.       if (!ignore_env && (sh = getenv ("LINES")))
  1305.     screenheight = atoi (sh);
  1306.  
  1307.       if (screenheight <= 0 && term_string_buffer)
  1308.     screenheight = tgetnum ("li");
  1309.     }
  1310.  
  1311.   /* If all else fails, default to 80x24 terminal. */
  1312.   if (screenwidth <= 1)
  1313.     screenwidth = 80;
  1314.  
  1315.   if (screenheight <= 0)
  1316.     screenheight = 24;
  1317.  
  1318. #if defined (SHELL)
  1319.   /* If we're being compiled as part of bash, set the environment
  1320.      variables $LINES and $COLUMNS to new values. */
  1321.   set_lines_and_columns (screenheight, screenwidth);
  1322. #endif
  1323.  
  1324.   if (!term_xn)
  1325.     screenwidth--;
  1326.  
  1327.   screenchars = screenwidth * screenheight;
  1328. }
  1329.  
  1330. struct _tc_string {
  1331.      char *tc_var;
  1332.      char **tc_value;
  1333. };
  1334.  
  1335. /* This should be kept sorted, just in case we decide to change the
  1336.    search algorithm to something smarter. */
  1337. static struct _tc_string tc_strings[] =
  1338. {
  1339.   "DC", &term_DC,
  1340.   "IC", &term_IC,
  1341.   "ce", &term_clreol,
  1342.   "cl", &term_clrpag,
  1343.   "cr", &term_cr,
  1344.   "dc", &term_dc,
  1345.   "ei", &term_ei,
  1346.   "ic", &term_ic,
  1347.   "im", &term_im,
  1348.   "kd", &term_kd,
  1349.   "kl", &term_kl,
  1350.   "kr", &term_kr,
  1351.   "ku", &term_ku,
  1352.   "ks", &term_ks,
  1353.   "ke", &term_ke,
  1354.   "le", &term_backspace,
  1355.   "mm", &term_mm,
  1356.   "mo", &term_mo,
  1357. #if defined (HACK_TERMCAP_MOTION)
  1358.   "nd", &term_forward_char,
  1359. #endif
  1360.   "pc", &term_pc,
  1361.   "up", &term_up,
  1362.   "vb", &visible_bell,
  1363. };
  1364.  
  1365. #define NUM_TC_STRINGS (sizeof (tc_strings) / sizeof (struct _tc_string))
  1366.  
  1367. /* Read the desired terminal capability strings into BP.  The capabilities
  1368.    are described in the TC_STRINGS table. */
  1369. static void
  1370. get_term_capabilities (bp)
  1371.      char **bp;
  1372. {
  1373.   register int i;
  1374.  
  1375.   for (i = 0; i < NUM_TC_STRINGS; i++)
  1376.     *(tc_strings[i].tc_value) = tgetstr (tc_strings[i].tc_var, bp);
  1377.   tcap_initialized = 1;
  1378. }
  1379.  
  1380. static int
  1381. init_terminal_io (terminal_name)
  1382.      char *terminal_name;
  1383. {
  1384. #if defined (__GO32__)
  1385.   screenwidth = ScreenCols ();
  1386.   screenheight = ScreenRows ();
  1387.   screenchars = screenwidth * screenheight;
  1388.   term_cr = "\r";
  1389.   term_im = term_ei = term_ic = term_IC = (char *)NULL;
  1390.   term_up = term_dc = term_DC = visible_bell = (char *)NULL;
  1391.  
  1392.   /* Does the __GO32__ have a meta key?  I don't know. */
  1393.   term_has_meta = 0;
  1394.   term_mm = term_mo = (char *)NULL;
  1395.  
  1396.   /* It probably has arrow keys, but I don't know what they are. */
  1397.   term_ku = term_kd = term_kr = term_kl = (char *)NULL;
  1398.  
  1399. #if defined (HACK_TERMCAP_MOTION)
  1400.   term_forward_char = (char *)NULL;
  1401. #endif /* HACK_TERMCAP_MOTION */
  1402.   terminal_can_insert = term_xn = 0;
  1403.   return;
  1404. #else /* !__GO32__ */
  1405.  
  1406.   char *term, *buffer;
  1407.   int tty;
  1408.   Keymap xkeymap;
  1409.  
  1410.   term = terminal_name ? terminal_name : getenv ("TERM");
  1411.  
  1412.   if (!term_string_buffer)
  1413.     term_string_buffer = xmalloc (2048);
  1414.  
  1415.   if (!term_buffer)
  1416.     term_buffer = xmalloc (2048);
  1417.  
  1418.   buffer = term_string_buffer;
  1419.  
  1420.   term_clrpag = term_cr = term_clreol = (char *)NULL;
  1421.  
  1422.   if (!term)
  1423.     term = "dumb";
  1424.  
  1425.   if (tgetent (term_buffer, term) <= 0)
  1426.     {
  1427.       dumb_term = 1;
  1428.       screenwidth = 79;
  1429.       screenheight = 24;
  1430.       screenchars = 79 * 24;
  1431.       term_cr = "\r";
  1432.       term_im = term_ei = term_ic = term_IC = (char *)NULL;
  1433.       term_up = term_dc = term_DC = visible_bell = (char *)NULL;
  1434.       term_ku = term_kd = term_kl = term_kr = (char *)NULL;
  1435. #if defined (HACK_TERMCAP_MOTION)
  1436.       term_forward_char = (char *)NULL;
  1437. #endif
  1438.       terminal_can_insert = 0;
  1439.       return 0;
  1440.     }
  1441.  
  1442.   get_term_capabilities (&buffer);
  1443.  
  1444.   /* Set up the variables that the termcap library expects the application
  1445.      to provide. */
  1446.   PC = term_pc ? *term_pc : 0;
  1447.   BC = term_backspace;
  1448.   UP = term_up;
  1449.  
  1450.   if (!term_cr)
  1451.     term_cr =  "\r";
  1452.  
  1453.   if (rl_instream)
  1454.     tty = fileno (rl_instream);
  1455.   else
  1456.     tty = 0;
  1457.  
  1458.   screenwidth = screenheight = 0;
  1459.  
  1460.   term_xn = tgetflag ("am") && tgetflag ("xn");
  1461.  
  1462.   _rl_set_screen_size (tty, 0);
  1463.  
  1464.   /* "An application program can assume that the terminal can do
  1465.       character insertion if *any one of* the capabilities `IC',
  1466.       `im', `ic' or `ip' is provided."  But we can't do anything if
  1467.       only `ip' is provided, so... */
  1468.   terminal_can_insert = (term_IC || term_im || term_ic);
  1469.  
  1470.   /* Check to see if this terminal has a meta key and clear the capability
  1471.      variables if there is none. */
  1472.   term_has_meta = (tgetflag ("km") || tgetflag ("MT"));
  1473.   if (!term_has_meta)
  1474.     {
  1475.       term_mm = (char *)NULL;
  1476.       term_mo = (char *)NULL;
  1477.     }
  1478.  
  1479.   /* Attempt to find and bind the arrow keys.  Do not override already
  1480.      bound keys in an overzealous attempt, however. */
  1481.   xkeymap = _rl_keymap;
  1482.  
  1483.   _rl_keymap = emacs_standard_keymap;
  1484.   _rl_bind_if_unbound (term_ku, rl_get_previous_history);
  1485.   _rl_bind_if_unbound (term_kd, rl_get_next_history);
  1486.   _rl_bind_if_unbound (term_kr, rl_forward);
  1487.   _rl_bind_if_unbound (term_kl, rl_backward);
  1488.  
  1489. #if defined (VI_MODE)
  1490.   _rl_keymap = vi_movement_keymap;
  1491.   _rl_bind_if_unbound (term_ku, rl_get_previous_history);
  1492.   _rl_bind_if_unbound (term_kd, rl_get_next_history);
  1493.   _rl_bind_if_unbound (term_kr, rl_forward);
  1494.   _rl_bind_if_unbound (term_kl, rl_backward);
  1495. #endif /* VI_MODE */
  1496.  
  1497.   _rl_keymap = xkeymap;
  1498.  
  1499. #endif /* !__GO32__ */
  1500.   return 0;
  1501. }
  1502.  
  1503. char *
  1504. rl_get_termcap (cap)
  1505.      char *cap;
  1506. {
  1507.   register int i;
  1508.  
  1509.   if (tcap_initialized == 0)
  1510.     return ((char *)NULL);
  1511.   for (i = 0; i < NUM_TC_STRINGS; i++)
  1512.     {
  1513.       if (tc_strings[i].tc_var[0] == cap[0] && strcmp (tc_strings[i].tc_var, cap) == 0)
  1514.         return *(tc_strings[i].tc_value);
  1515.     }
  1516.   return ((char *)NULL);
  1517. }
  1518.  
  1519. /* A function for the use of tputs () */
  1520. int
  1521. _rl_output_character_function (c)
  1522.      int c;
  1523. {
  1524.   return putc (c, out_stream);
  1525. }
  1526.  
  1527. /* Write COUNT characters from STRING to the output stream. */
  1528. void
  1529. _rl_output_some_chars (string, count)
  1530.      char *string;
  1531.      int count;
  1532. {
  1533.   fwrite (string, 1, count, out_stream);
  1534. }
  1535.  
  1536. /* Move the cursor back. */
  1537. backspace (count)
  1538.      int count;
  1539. {
  1540.   register int i;
  1541.  
  1542. #if !defined (__GO32__)
  1543.   if (term_backspace)
  1544.     for (i = 0; i < count; i++)
  1545.       tputs (term_backspace, 1, _rl_output_character_function);
  1546.   else
  1547. #endif /* !__GO32__ */
  1548.     for (i = 0; i < count; i++)
  1549.       putc ('\b', out_stream);
  1550.   return 0;
  1551. }
  1552.  
  1553. /* Move to the start of the next line. */
  1554. crlf ()
  1555. {
  1556. #if defined (NEW_TTY_DRIVER)
  1557.   tputs (term_cr, 1, _rl_output_character_function);
  1558. #endif /* NEW_TTY_DRIVER */
  1559.   putc ('\n', out_stream);
  1560.   return 0;
  1561. }
  1562.  
  1563. rl_tty_status (count, key)
  1564.      int count, key;
  1565. {
  1566. #if defined (TIOCSTAT)
  1567.   ioctl (1, TIOCSTAT, (char *)0);
  1568.   rl_refresh_line ();
  1569. #else
  1570.   ding ();
  1571. #endif
  1572.   return 0;
  1573. }
  1574.  
  1575.  
  1576. /* **************************************************************** */
  1577. /*                                    */
  1578. /*            Utility Functions                */
  1579. /*                                    */
  1580. /* **************************************************************** */
  1581.  
  1582. /* Return 0 if C is not a member of the class of characters that belong
  1583.    in words, or 1 if it is. */
  1584.  
  1585. int allow_pathname_alphabetic_chars = 0;
  1586. char *pathname_alphabetic_chars = "/-_=~.#$";
  1587.  
  1588. int
  1589. alphabetic (c)
  1590.      int c;
  1591. {
  1592.   if (pure_alphabetic (c) || (digit_p (c)))
  1593.     return (1);
  1594.  
  1595.   if (allow_pathname_alphabetic_chars)
  1596.     return (strchr (pathname_alphabetic_chars, c) != NULL);
  1597.   else
  1598.     return (0);
  1599. }
  1600.  
  1601. /* Ring the terminal bell. */
  1602. int
  1603. ding ()
  1604. {
  1605.   if (readline_echoing_p)
  1606.     {
  1607. #if !defined (__GO32__)
  1608.       switch (_rl_bell_preference)
  1609.         {
  1610.     case NO_BELL:
  1611.     default:
  1612.       break;
  1613.     case VISIBLE_BELL:
  1614.       if (visible_bell)
  1615.         {
  1616.           tputs (visible_bell, 1, _rl_output_character_function);
  1617.           break;
  1618.         }
  1619.       /* FALLTHROUGH */
  1620.     case AUDIBLE_BELL:
  1621.       fprintf (stderr, "\007");
  1622.       fflush (stderr);
  1623.       break;
  1624.         }
  1625. #else /* __GO32__ */
  1626.       fprintf (stderr, "\007");
  1627.       fflush (stderr);
  1628. #endif /* __GO32__ */
  1629.       return (0);
  1630.     }
  1631.   return (-1);
  1632. }
  1633.  
  1634. /* How to abort things. */
  1635. rl_abort (count, key)
  1636.      int count, key;
  1637. {
  1638.   ding ();
  1639.   rl_clear_message ();
  1640.   rl_init_argument ();
  1641.   rl_pending_input = 0;
  1642.  
  1643.   defining_kbd_macro = 0;
  1644.   while (executing_macro)
  1645.     pop_executing_macro ();
  1646.  
  1647.   rl_last_func = (Function *)NULL;
  1648.   longjmp (readline_top_level, 1);
  1649. }
  1650.  
  1651. /* Return a copy of the string between FROM and TO.
  1652.    FROM is inclusive, TO is not. */
  1653. char *
  1654. rl_copy_text (from, to)
  1655.      int from, to;
  1656. {
  1657.   register int length;
  1658.   char *copy;
  1659.  
  1660.   /* Fix it if the caller is confused. */
  1661.   if (from > to)
  1662.     {
  1663.       int t = from;
  1664.       from = to;
  1665.       to = t;
  1666.     }
  1667.  
  1668.   length = to - from;
  1669.   copy = xmalloc (1 + length);
  1670.   strncpy (copy, the_line + from, length);
  1671.   copy[length] = '\0';
  1672.   return (copy);
  1673. }
  1674.  
  1675. /* Increase the size of RL_LINE_BUFFER until it has enough space to hold
  1676.    LEN characters. */
  1677. void
  1678. rl_extend_line_buffer (len)
  1679.      int len;
  1680. {
  1681.   while (len >= rl_line_buffer_len)
  1682.     {
  1683.       rl_line_buffer_len += DEFAULT_BUFFER_SIZE;
  1684.       rl_line_buffer = xrealloc (rl_line_buffer, rl_line_buffer_len);
  1685.     }
  1686.  
  1687.   the_line = rl_line_buffer;
  1688. }
  1689.  
  1690.  
  1691. /* **************************************************************** */
  1692. /*                                    */
  1693. /*            Insert and Delete                */
  1694. /*                                    */
  1695. /* **************************************************************** */
  1696.  
  1697. /* Insert a string of text into the line at point.  This is the only
  1698.    way that you should do insertion.  rl_insert () calls this
  1699.    function. */
  1700. rl_insert_text (string)
  1701.      char *string;
  1702. {
  1703.   register int i, l = strlen (string);
  1704.  
  1705.   if (rl_end + l >= rl_line_buffer_len)
  1706.     rl_extend_line_buffer (rl_end + l);
  1707.  
  1708.   for (i = rl_end; i >= rl_point; i--)
  1709.     the_line[i + l] = the_line[i];
  1710.   strncpy (the_line + rl_point, string, l);
  1711.  
  1712.   /* Remember how to undo this if we aren't undoing something. */
  1713.   if (!doing_an_undo)
  1714.     {
  1715.       /* If possible and desirable, concatenate the undos. */
  1716.       if ((l == 1) &&
  1717.       rl_undo_list &&
  1718.       (rl_undo_list->what == UNDO_INSERT) &&
  1719.       (rl_undo_list->end == rl_point) &&
  1720.       (rl_undo_list->end - rl_undo_list->start < 20))
  1721.     rl_undo_list->end++;
  1722.       else
  1723.     rl_add_undo (UNDO_INSERT, rl_point, rl_point + l, (char *)NULL);
  1724.     }
  1725.   rl_point += l;
  1726.   rl_end += l;
  1727.   the_line[rl_end] = '\0';
  1728.   return l;
  1729. }
  1730.  
  1731. /* Delete the string between FROM and TO.  FROM is
  1732.    inclusive, TO is not. */
  1733. rl_delete_text (from, to)
  1734.      int from, to;
  1735. {
  1736.   register char *text;
  1737.   register int diff, i;
  1738.  
  1739.   /* Fix it if the caller is confused. */
  1740.   if (from > to)
  1741.     {
  1742.       int t = from;
  1743.       from = to;
  1744.       to = t;
  1745.     }
  1746.  
  1747.   if (to > rl_end)
  1748.     to = rl_end;
  1749.  
  1750.   text = rl_copy_text (from, to);
  1751.  
  1752.   /* Some versions of strncpy() can't handle overlapping arguments. */
  1753.   diff = to - from;
  1754.   for (i = from; i < rl_end - diff; i++)
  1755.     the_line[i] = the_line[i + diff];
  1756.  
  1757.   /* Remember how to undo this delete. */
  1758.   if (!doing_an_undo)
  1759.     rl_add_undo (UNDO_DELETE, from, to, text);
  1760.   else
  1761.     free (text);
  1762.  
  1763.   rl_end -= diff;
  1764.   the_line[rl_end] = '\0';
  1765.   return (diff);
  1766. }
  1767.  
  1768.  
  1769. /* **************************************************************** */
  1770. /*                                    */
  1771. /*            Readline character functions            */
  1772. /*                                    */
  1773. /* **************************************************************** */
  1774.  
  1775. /* This is not a gap editor, just a stupid line input routine.  No hair
  1776.    is involved in writing any of the functions, and none should be. */
  1777.  
  1778. /* Note that:
  1779.  
  1780.    rl_end is the place in the string that we would place '\0';
  1781.    i.e., it is always safe to place '\0' there.
  1782.  
  1783.    rl_point is the place in the string where the cursor is.  Sometimes
  1784.    this is the same as rl_end.
  1785.  
  1786.    Any command that is called interactively receives two arguments.
  1787.    The first is a count: the numeric arg pased to this command.
  1788.    The second is the key which invoked this command.
  1789. */
  1790.  
  1791.  
  1792. /* **************************************************************** */
  1793. /*                                    */
  1794. /*            Movement Commands                */
  1795. /*                                    */
  1796. /* **************************************************************** */
  1797.  
  1798. /* Note that if you `optimize' the display for these functions, you cannot
  1799.    use said functions in other functions which do not do optimizing display.
  1800.    I.e., you will have to update the data base for rl_redisplay, and you
  1801.    might as well let rl_redisplay do that job. */
  1802.  
  1803. /* Move forward COUNT characters. */
  1804. rl_forward (count, key)
  1805.      int count, key;
  1806. {
  1807.   if (count < 0)
  1808.     rl_backward (-count);
  1809.   else if (count > 0)
  1810.     {
  1811.       int end = rl_point + count;
  1812. #if defined (VI_MODE)
  1813.       int lend = rl_end - (rl_editing_mode == vi_mode);
  1814. #else
  1815.       int lend = rl_end;
  1816. #endif
  1817.  
  1818.       if (end > lend)
  1819.     {
  1820.       rl_point = lend;
  1821.       ding ();
  1822.     }
  1823.       else
  1824.     rl_point = end;
  1825.     }
  1826.   return 0;
  1827. }
  1828.  
  1829. /* Move backward COUNT characters. */
  1830. rl_backward (count, key)
  1831.      int count, key;
  1832. {
  1833.   if (count < 0)
  1834.     rl_forward (-count);
  1835.   else if (count > 0)
  1836.     {
  1837.       if (rl_point < count)
  1838.     {
  1839.       rl_point = 0;
  1840.       ding ();
  1841.     }
  1842.       else
  1843.         rl_point -= count;
  1844.     }
  1845.   return 0;
  1846. }
  1847.  
  1848. /* Move to the beginning of the line. */
  1849. rl_beg_of_line (count, key)
  1850.      int count, key;
  1851. {
  1852.   rl_point = 0;
  1853.   return 0;
  1854. }
  1855.  
  1856. /* Move to the end of the line. */
  1857. rl_end_of_line (count, key)
  1858.      int count, key;
  1859. {
  1860.   rl_point = rl_end;
  1861.   return 0;
  1862. }
  1863.  
  1864. /* Move forward a word.  We do what Emacs does. */
  1865. rl_forward_word (count, key)
  1866.      int count, key;
  1867. {
  1868.   int c;
  1869.  
  1870.   if (count < 0)
  1871.     {
  1872.       rl_backward_word (-count);
  1873.       return 0;
  1874.     }
  1875.  
  1876.   while (count)
  1877.     {
  1878.       if (rl_point == rl_end)
  1879.     return 0;
  1880.  
  1881.       /* If we are not in a word, move forward until we are in one.
  1882.      Then, move forward until we hit a non-alphabetic character. */
  1883.       c = the_line[rl_point];
  1884.       if (!alphabetic (c))
  1885.     {
  1886.       while (++rl_point < rl_end)
  1887.         {
  1888.           c = the_line[rl_point];
  1889.           if (alphabetic (c))
  1890.         break;
  1891.         }
  1892.     }
  1893.       if (rl_point == rl_end)
  1894.     return 0;
  1895.       while (++rl_point < rl_end)
  1896.     {
  1897.       c = the_line[rl_point];
  1898.       if (!alphabetic (c))
  1899.         break;
  1900.     }
  1901.       --count;
  1902.     }
  1903.   return 0;
  1904. }
  1905.  
  1906. /* Move backward a word.  We do what Emacs does. */
  1907. rl_backward_word (count, key)
  1908.      int count, key;
  1909. {
  1910.   int c;
  1911.  
  1912.   if (count < 0)
  1913.     {
  1914.       rl_forward_word (-count);
  1915.       return 0;
  1916.     }
  1917.  
  1918.   while (count)
  1919.     {
  1920.       if (!rl_point)
  1921.     return 0;
  1922.  
  1923.       /* Like rl_forward_word (), except that we look at the characters
  1924.      just before point. */
  1925.  
  1926.       c = the_line[rl_point - 1];
  1927.       if (!alphabetic (c))
  1928.     {
  1929.       while (--rl_point)
  1930.         {
  1931.           c = the_line[rl_point - 1];
  1932.           if (alphabetic (c))
  1933.         break;
  1934.         }
  1935.     }
  1936.  
  1937.       while (rl_point)
  1938.     {
  1939.       c = the_line[rl_point - 1];
  1940.       if (!alphabetic (c))
  1941.         break;
  1942.       else
  1943.         --rl_point;
  1944.     }
  1945.       --count;
  1946.     }
  1947.   return 0;
  1948. }
  1949.  
  1950. /* Clear the current line.  Numeric argument to C-l does this. */
  1951. rl_refresh_line ()
  1952. {
  1953.   int curr_line, nleft;
  1954.  
  1955.   /* Find out whether or not there might be invisible characters in the
  1956.      editing buffer. */
  1957.   if (rl_display_prompt == rl_prompt)
  1958.     nleft = _rl_last_c_pos - screenwidth - rl_visible_prompt_length;
  1959.   else
  1960.     nleft = _rl_last_c_pos - screenwidth;
  1961.  
  1962.   if (nleft > 0)
  1963.     curr_line = 1 + nleft / screenwidth;
  1964.   else
  1965.     curr_line = 0;
  1966.  
  1967.   _rl_move_vert (curr_line);
  1968.   _rl_move_cursor_relative (0, the_line);   /* XXX is this right */
  1969.  
  1970. #if defined (__GO32__)
  1971.   {
  1972.     int row, col, width, row_start;
  1973.  
  1974.     ScreenGetCursor (&row, &col);
  1975.     width = ScreenCols ();
  1976.     row_start = ScreenPrimary + (row * width);
  1977.     memset (row_start + col, 0, (width - col) * 2);
  1978.   }
  1979. #else /* !__GO32__ */
  1980.   if (term_clreol)
  1981.     tputs (term_clreol, 1, _rl_output_character_function);
  1982. #endif /* !__GO32__ */
  1983.  
  1984.   rl_forced_update_display ();
  1985.   rl_display_fixed = 1;
  1986.  
  1987.   return 0;
  1988. }
  1989.  
  1990. /* C-l typed to a line without quoting clears the screen, and then reprints
  1991.    the prompt and the current input line.  Given a numeric arg, redraw only
  1992.    the current line. */
  1993. rl_clear_screen (count, key)
  1994.      int count, key;
  1995. {
  1996.   if (rl_explicit_arg)
  1997.     {
  1998.       rl_refresh_line ();
  1999.       return 0;
  2000.     }
  2001.  
  2002. #if !defined (__GO32__)
  2003.   if (term_clrpag)
  2004.     tputs (term_clrpag, 1, _rl_output_character_function);
  2005.   else
  2006. #endif /* !__GO32__ */
  2007.     crlf ();
  2008.  
  2009.   rl_forced_update_display ();
  2010.   rl_display_fixed = 1;
  2011.  
  2012.   return 0;
  2013. }
  2014.  
  2015. rl_arrow_keys (count, c)
  2016.      int count, c;
  2017. {
  2018.   int ch;
  2019.  
  2020.   ch = rl_read_key ();
  2021.  
  2022.   switch (to_upper (ch))
  2023.     {
  2024.     case 'A':
  2025.       rl_get_previous_history (count);
  2026.       break;
  2027.  
  2028.     case 'B':
  2029.       rl_get_next_history (count);
  2030.       break;
  2031.  
  2032.     case 'C':
  2033.       rl_forward (count);
  2034.       break;
  2035.  
  2036.     case 'D':
  2037.       rl_backward (count);
  2038.       break;
  2039.  
  2040.     default:
  2041.       ding ();
  2042.     }
  2043.   return 0;
  2044. }
  2045.  
  2046.  
  2047. /* **************************************************************** */
  2048. /*                                    */
  2049. /*            Text commands                    */
  2050. /*                                    */
  2051. /* **************************************************************** */
  2052.  
  2053. /* Insert the character C at the current location, moving point forward. */
  2054. rl_insert (count, c)
  2055.      int count, c;
  2056. {
  2057.   register int i;
  2058.   char *string;
  2059.  
  2060.   if (count <= 0)
  2061.     return 0;
  2062.  
  2063.   /* If we can optimize, then do it.  But don't let people crash
  2064.      readline because of extra large arguments. */
  2065.   if (count > 1 && count < 1024)
  2066.     {
  2067.       string = xmalloc (1 + count);
  2068.  
  2069.       for (i = 0; i < count; i++)
  2070.     string[i] = c;
  2071.  
  2072.       string[i] = '\0';
  2073.       rl_insert_text (string);
  2074.       free (string);
  2075.  
  2076.       return 0;
  2077.     }
  2078.  
  2079.   if (count > 1024)
  2080.     {
  2081.       int decreaser;
  2082.       char str[1024+1];
  2083.  
  2084.       for (i = 0; i < 1024; i++)
  2085.     str[i] = c;
  2086.  
  2087.       while (count)
  2088.     {
  2089.       decreaser = (count > 1024 ? 1024 : count);
  2090.       str[decreaser] = '\0';
  2091.       rl_insert_text (str);
  2092.       count -= decreaser;
  2093.     }
  2094.  
  2095.       return 0;
  2096.     }
  2097.  
  2098.   /* We are inserting a single character.
  2099.      If there is pending input, then make a string of all of the
  2100.      pending characters that are bound to rl_insert, and insert
  2101.      them all. */
  2102.   if (any_typein)
  2103.     {
  2104.       int key = 0, t;
  2105.  
  2106.       i = 0;
  2107.       string = xmalloc (ibuffer_len + 1);
  2108.       string[i++] = c;
  2109.  
  2110.       while ((t = rl_get_char (&key)) &&
  2111.          (_rl_keymap[key].type == ISFUNC &&
  2112.           _rl_keymap[key].function == rl_insert))
  2113.     string[i++] = key;
  2114.  
  2115.       if (t)
  2116.     rl_unget_char (key);
  2117.  
  2118.       string[i] = '\0';
  2119.       rl_insert_text (string);
  2120.       free (string);
  2121.     }
  2122.   else
  2123.     {
  2124.       /* Inserting a single character. */
  2125.       char str[2];
  2126.  
  2127.       str[1] = '\0';
  2128.       str[0] = c;
  2129.       rl_insert_text (str);
  2130.     }
  2131.   return 0;
  2132. }
  2133.  
  2134. /* Insert the next typed character verbatim. */
  2135. rl_quoted_insert (count, key)
  2136.      int count, key;
  2137. {
  2138.   int c;
  2139.  
  2140.   c = rl_read_key ();
  2141.   return (rl_insert (count, c));  
  2142. }
  2143.  
  2144. /* Insert a tab character. */
  2145. rl_tab_insert (count, key)
  2146.      int count, key;
  2147. {
  2148.   return (rl_insert (count, '\t'));
  2149. }
  2150.  
  2151. /* What to do when a NEWLINE is pressed.  We accept the whole line.
  2152.    KEY is the key that invoked this command.  I guess it could have
  2153.    meaning in the future. */
  2154. rl_newline (count, key)
  2155.      int count, key;
  2156. {
  2157.   rl_done = 1;
  2158.  
  2159. #if defined (VI_MODE)
  2160.   _rl_vi_done_inserting ();
  2161.   _rl_vi_reset_last ();
  2162.  
  2163. #endif /* VI_MODE */
  2164.  
  2165.   if (readline_echoing_p)
  2166.     _rl_update_final ();
  2167.   return 0;
  2168. }
  2169.  
  2170. rl_clean_up_for_exit ()
  2171. {
  2172.   if (readline_echoing_p)
  2173.     {
  2174.       _rl_move_vert (_rl_vis_botlin);
  2175.       _rl_vis_botlin = 0;
  2176.       fflush (out_stream);
  2177.       rl_restart_output ();
  2178.     }
  2179.   return 0;
  2180. }
  2181.  
  2182. /* What to do for some uppercase characters, like meta characters,
  2183.    and some characters appearing in emacs_ctlx_keymap.  This function
  2184.    is just a stub, you bind keys to it and the code in _rl_dispatch ()
  2185.    is special cased. */
  2186. rl_do_lowercase_version (ignore1, ignore2)
  2187.      int ignore1, ignore2;
  2188. {
  2189.   return 0;
  2190. }
  2191.  
  2192. /* Rubout the character behind point. */
  2193. rl_rubout (count, key)
  2194.      int count, key;
  2195. {
  2196.   if (count < 0)
  2197.     {
  2198.       rl_delete (-count);
  2199.       return 0;
  2200.     }
  2201.  
  2202.   if (!rl_point)
  2203.     {
  2204.       ding ();
  2205.       return -1;
  2206.     }
  2207.  
  2208.   if (count > 1 || rl_explicit_arg)
  2209.     {
  2210.       int orig_point = rl_point;
  2211.       rl_backward (count);
  2212.       rl_kill_text (orig_point, rl_point);
  2213.     }
  2214.   else
  2215.     {
  2216.       int c = the_line[--rl_point];
  2217.       rl_delete_text (rl_point, rl_point + 1);
  2218.  
  2219.       if (rl_point == rl_end && isprint (c) && _rl_last_c_pos)
  2220.     {
  2221.       int l;
  2222.       l = rl_character_len (c, rl_point);
  2223.       _rl_erase_at_end_of_line (l);
  2224.     }
  2225.     }
  2226.   return 0;
  2227. }
  2228.  
  2229. /* Delete the character under the cursor.  Given a numeric argument,
  2230.    kill that many characters instead. */
  2231. rl_delete (count, invoking_key)
  2232.      int count, invoking_key;
  2233. {
  2234.   if (count < 0)
  2235.     {
  2236.       return (rl_rubout (-count));
  2237.     }
  2238.  
  2239.   if (rl_point == rl_end)
  2240.     {
  2241.       ding ();
  2242.       return -1;
  2243.     }
  2244.  
  2245.   if (count > 1 || rl_explicit_arg)
  2246.     {
  2247.       int orig_point = rl_point;
  2248.       rl_forward (count);
  2249.       rl_kill_text (orig_point, rl_point);
  2250.       rl_point = orig_point;
  2251.       return 0;
  2252.     }
  2253.   else
  2254.     return (rl_delete_text (rl_point, rl_point + 1));
  2255.   
  2256. }
  2257.  
  2258. /* Delete all spaces and tabs around point. */
  2259. rl_delete_horizontal_space (count, ignore)
  2260.      int count, ignore;
  2261. {
  2262.   int start = rl_point;
  2263.  
  2264.   while (rl_point && whitespace (the_line[rl_point - 1]))
  2265.     rl_point--;
  2266.  
  2267.   start = rl_point;
  2268.  
  2269.   while (rl_point < rl_end && whitespace (the_line[rl_point]))
  2270.     rl_point++;
  2271.  
  2272.   if (start != rl_point)
  2273.     {
  2274.       rl_delete_text (start, rl_point);
  2275.       rl_point = start;
  2276.     }
  2277.   return 0;
  2278. }
  2279.  
  2280.  
  2281. /* **************************************************************** */
  2282. /*                                    */
  2283. /*            Kill commands                    */
  2284. /*                                    */
  2285. /* **************************************************************** */
  2286.  
  2287. /* The next two functions mimic unix line editing behaviour, except they
  2288.    save the deleted text on the kill ring.  This is safer than not saving
  2289.    it, and since we have a ring, nobody should get screwed. */
  2290.  
  2291. /* This does what C-w does in Unix.  We can't prevent people from
  2292.    using behaviour that they expect. */
  2293. rl_unix_word_rubout (count, key)
  2294.      int count, key;
  2295. {
  2296.   if (!rl_point)
  2297.     ding ();
  2298.   else
  2299.     {
  2300.       int orig_point = rl_point;
  2301.       if (count <= 0)
  2302.     count = 1;
  2303.  
  2304.       while (count--)
  2305.     {
  2306.       while (rl_point && whitespace (the_line[rl_point - 1]))
  2307.         rl_point--;
  2308.  
  2309.       while (rl_point && !whitespace (the_line[rl_point - 1]))
  2310.         rl_point--;
  2311.     }
  2312.  
  2313.       rl_kill_text (orig_point, rl_point);
  2314.     }
  2315.   return 0;
  2316. }
  2317.  
  2318. /* Here is C-u doing what Unix does.  You don't *have* to use these
  2319.    key-bindings.  We have a choice of killing the entire line, or
  2320.    killing from where we are to the start of the line.  We choose the
  2321.    latter, because if you are a Unix weenie, then you haven't backspaced
  2322.    into the line at all, and if you aren't, then you know what you are
  2323.    doing. */
  2324. rl_unix_line_discard (count, key)
  2325.      int count, key;
  2326. {
  2327.   if (!rl_point)
  2328.     ding ();
  2329.   else
  2330.     {
  2331.       rl_kill_text (rl_point, 0);
  2332.       rl_point = 0;
  2333.     }
  2334.   return 0;
  2335. }
  2336.  
  2337.  
  2338. /* **************************************************************** */
  2339. /*                                    */
  2340. /*            Commands For Typos                */
  2341. /*                                    */
  2342. /* **************************************************************** */
  2343.  
  2344. /* Random and interesting things in here.  */
  2345.  
  2346. /* **************************************************************** */
  2347. /*                                    */
  2348. /*            Changing Case                    */
  2349. /*                                    */
  2350. /* **************************************************************** */
  2351.  
  2352. /* The three kinds of things that we know how to do. */
  2353. #define UpCase 1
  2354. #define DownCase 2
  2355. #define CapCase 3
  2356.  
  2357. static int rl_change_case ();
  2358.  
  2359. /* Uppercase the word at point. */
  2360. rl_upcase_word (count, key)
  2361.      int count, key;
  2362. {
  2363.   return (rl_change_case (count, UpCase));
  2364. }
  2365.  
  2366. /* Lowercase the word at point. */
  2367. rl_downcase_word (count, key)
  2368.      int count, key;
  2369. {
  2370.   return (rl_change_case (count, DownCase));
  2371. }
  2372.  
  2373. /* Upcase the first letter, downcase the rest. */
  2374. rl_capitalize_word (count, key)
  2375.      int count, key;
  2376. {
  2377.  return (rl_change_case (count, CapCase));
  2378. }
  2379.  
  2380. /* The meaty function.
  2381.    Change the case of COUNT words, performing OP on them.
  2382.    OP is one of UpCase, DownCase, or CapCase.
  2383.    If a negative argument is given, leave point where it started,
  2384.    otherwise, leave it where it moves to. */
  2385. static int
  2386. rl_change_case (count, op)
  2387.      int count, op;
  2388. {
  2389.   register int start = rl_point, end;
  2390.   int state = 0;
  2391.  
  2392.   rl_forward_word (count);
  2393.   end = rl_point;
  2394.  
  2395.   if (count < 0)
  2396.     {
  2397.       int temp = start;
  2398.       start = end;
  2399.       end = temp;
  2400.     }
  2401.  
  2402.   /* We are going to modify some text, so let's prepare to undo it. */
  2403.   rl_modifying (start, end);
  2404.  
  2405.   for (; start < end; start++)
  2406.     {
  2407.       switch (op)
  2408.     {
  2409.     case UpCase:
  2410.       the_line[start] = to_upper (the_line[start]);
  2411.       break;
  2412.  
  2413.     case DownCase:
  2414.       the_line[start] = to_lower (the_line[start]);
  2415.       break;
  2416.  
  2417.     case CapCase:
  2418.       if (state == 0)
  2419.         {
  2420.           the_line[start] = to_upper (the_line[start]);
  2421.           state = 1;
  2422.         }
  2423.       else
  2424.         {
  2425.           the_line[start] = to_lower (the_line[start]);
  2426.         }
  2427.       if (!pure_alphabetic (the_line[start]))
  2428.         state = 0;
  2429.       break;
  2430.  
  2431.     default:
  2432.       ding ();
  2433.       return -1;
  2434.     }
  2435.     }
  2436.   rl_point = end;
  2437.   return 0;
  2438. }
  2439.  
  2440. /* **************************************************************** */
  2441. /*                                    */
  2442. /*            Transposition                    */
  2443. /*                                    */
  2444. /* **************************************************************** */
  2445.  
  2446. /* Transpose the words at point. */
  2447. rl_transpose_words (count, key)
  2448.      int count, key;
  2449. {
  2450.   char *word1, *word2;
  2451.   int w1_beg, w1_end, w2_beg, w2_end;
  2452.   int orig_point = rl_point;
  2453.  
  2454.   if (!count)
  2455.     return 0;
  2456.  
  2457.   /* Find the two words. */
  2458.   rl_forward_word (count);
  2459.   w2_end = rl_point;
  2460.   rl_backward_word (1);
  2461.   w2_beg = rl_point;
  2462.   rl_backward_word (count);
  2463.   w1_beg = rl_point;
  2464.   rl_forward_word (1);
  2465.   w1_end = rl_point;
  2466.  
  2467.   /* Do some check to make sure that there really are two words. */
  2468.   if ((w1_beg == w2_beg) || (w2_beg < w1_end))
  2469.     {
  2470.       ding ();
  2471.       rl_point = orig_point;
  2472.       return -1;
  2473.     }
  2474.  
  2475.   /* Get the text of the words. */
  2476.   word1 = rl_copy_text (w1_beg, w1_end);
  2477.   word2 = rl_copy_text (w2_beg, w2_end);
  2478.  
  2479.   /* We are about to do many insertions and deletions.  Remember them
  2480.      as one operation. */
  2481.   rl_begin_undo_group ();
  2482.  
  2483.   /* Do the stuff at word2 first, so that we don't have to worry
  2484.      about word1 moving. */
  2485.   rl_point = w2_beg;
  2486.   rl_delete_text (w2_beg, w2_end);
  2487.   rl_insert_text (word1);
  2488.  
  2489.   rl_point = w1_beg;
  2490.   rl_delete_text (w1_beg, w1_end);
  2491.   rl_insert_text (word2);
  2492.  
  2493.   /* This is exactly correct since the text before this point has not
  2494.      changed in length. */
  2495.   rl_point = w2_end;
  2496.  
  2497.   /* I think that does it. */
  2498.   rl_end_undo_group ();
  2499.   free (word1);
  2500.   free (word2);
  2501.  
  2502.   return 0;
  2503. }
  2504.  
  2505. /* Transpose the characters at point.  If point is at the end of the line,
  2506.    then transpose the characters before point. */
  2507. rl_transpose_chars (count, key)
  2508.      int count, key;
  2509. {
  2510.   char dummy[2];
  2511.  
  2512.   if (!count)
  2513.     return 0;
  2514.  
  2515.   if (!rl_point || rl_end < 2)
  2516.     {
  2517.       ding ();
  2518.       return -1;
  2519.     }
  2520.  
  2521.   rl_begin_undo_group ();
  2522.  
  2523.   if (rl_point == rl_end)
  2524.     {
  2525.       --rl_point;
  2526.       count = 1;
  2527.     }
  2528.   rl_point--;
  2529.  
  2530.   dummy[0] = the_line[rl_point];
  2531.   dummy[1] = '\0';
  2532.  
  2533.   rl_delete_text (rl_point, rl_point + 1);
  2534.  
  2535.   rl_point += count;
  2536.   if (rl_point > rl_end)
  2537.     rl_point = rl_end;
  2538.   else if (rl_point < 0)
  2539.     rl_point = 0;
  2540.   rl_insert_text (dummy);
  2541.  
  2542.   rl_end_undo_group ();
  2543.   return 0;
  2544. }
  2545.  
  2546. /* **************************************************************** */
  2547. /*                                    */
  2548. /*            Undo, and Undoing                */
  2549. /*                                    */
  2550. /* **************************************************************** */
  2551.  
  2552. /* The current undo list for THE_LINE. */
  2553. UNDO_LIST *rl_undo_list = (UNDO_LIST *)NULL;
  2554.  
  2555. /* Remember how to undo something.  Concatenate some undos if that
  2556.    seems right. */
  2557. void
  2558. rl_add_undo (what, start, end, text)
  2559.      enum undo_code what;
  2560.      int start, end;
  2561.      char *text;
  2562. {
  2563.   UNDO_LIST *temp = (UNDO_LIST *)xmalloc (sizeof (UNDO_LIST));
  2564.   temp->what = what;
  2565.   temp->start = start;
  2566.   temp->end = end;
  2567.   temp->text = text;
  2568.   temp->next = rl_undo_list;
  2569.   rl_undo_list = temp;
  2570. }
  2571.  
  2572. /* Free the existing undo list. */
  2573. void
  2574. free_undo_list ()
  2575. {
  2576.   while (rl_undo_list)
  2577.     {
  2578.       UNDO_LIST *release = rl_undo_list;
  2579.       rl_undo_list = rl_undo_list->next;
  2580.  
  2581.       if (release->what == UNDO_DELETE)
  2582.     free (release->text);
  2583.  
  2584.       free (release);
  2585.     }
  2586.   rl_undo_list = (UNDO_LIST *)NULL;
  2587. }
  2588.  
  2589. /* Undo the next thing in the list.  Return 0 if there
  2590.    is nothing to undo, or non-zero if there was. */
  2591. int
  2592. rl_do_undo ()
  2593. {
  2594.   UNDO_LIST *release;
  2595.   int waiting_for_begin = 0;
  2596.  
  2597. undo_thing:
  2598.   if (!rl_undo_list)
  2599.     return (0);
  2600.  
  2601.   doing_an_undo = 1;
  2602.  
  2603.   switch (rl_undo_list->what) {
  2604.  
  2605.     /* Undoing deletes means inserting some text. */
  2606.   case UNDO_DELETE:
  2607.     rl_point = rl_undo_list->start;
  2608.     rl_insert_text (rl_undo_list->text);
  2609.     free (rl_undo_list->text);
  2610.     break;
  2611.  
  2612.     /* Undoing inserts means deleting some text. */
  2613.   case UNDO_INSERT:
  2614.     rl_delete_text (rl_undo_list->start, rl_undo_list->end);
  2615.     rl_point = rl_undo_list->start;
  2616.     break;
  2617.  
  2618.     /* Undoing an END means undoing everything 'til we get to
  2619.        a BEGIN. */
  2620.   case UNDO_END:
  2621.     waiting_for_begin++;
  2622.     break;
  2623.  
  2624.     /* Undoing a BEGIN means that we are done with this group. */
  2625.   case UNDO_BEGIN:
  2626.     if (waiting_for_begin)
  2627.       waiting_for_begin--;
  2628.     else
  2629.       ding ();
  2630.     break;
  2631.   }
  2632.  
  2633.   doing_an_undo = 0;
  2634.  
  2635.   release = rl_undo_list;
  2636.   rl_undo_list = rl_undo_list->next;
  2637.   free (release);
  2638.  
  2639.   if (waiting_for_begin)
  2640.     goto undo_thing;
  2641.  
  2642.   return (1);
  2643. }
  2644.  
  2645. /* Begin a group.  Subsequent undos are undone as an atomic operation. */
  2646. int
  2647. rl_begin_undo_group ()
  2648. {
  2649.   rl_add_undo (UNDO_BEGIN, 0, 0, 0);
  2650.   return 0;
  2651. }
  2652.  
  2653. /* End an undo group started with rl_begin_undo_group (). */
  2654. int
  2655. rl_end_undo_group ()
  2656. {
  2657.   rl_add_undo (UNDO_END, 0, 0, 0);
  2658.   return 0;
  2659. }
  2660.  
  2661. /* Save an undo entry for the text from START to END. */
  2662. rl_modifying (start, end)
  2663.      int start, end;
  2664. {
  2665.   if (start > end)
  2666.     {
  2667.       int t = start;
  2668.       start = end;
  2669.       end = t;
  2670.     }
  2671.  
  2672.   if (start != end)
  2673.     {
  2674.       char *temp = rl_copy_text (start, end);
  2675.       rl_begin_undo_group ();
  2676.       rl_add_undo (UNDO_DELETE, start, end, temp);
  2677.       rl_add_undo (UNDO_INSERT, start, end, (char *)NULL);
  2678.       rl_end_undo_group ();
  2679.     }
  2680.   return 0;
  2681. }
  2682.  
  2683. /* Revert the current line to its previous state. */
  2684. int
  2685. rl_revert_line (count, key)
  2686.      int count, key;
  2687. {
  2688.   if (!rl_undo_list)
  2689.     ding ();
  2690.   else
  2691.     {
  2692.       while (rl_undo_list)
  2693.     rl_do_undo ();
  2694.     }
  2695.   return 0;
  2696. }
  2697.  
  2698. /* Do some undoing of things that were done. */
  2699. int
  2700. rl_undo_command (count, key)
  2701.      int count, key;
  2702. {
  2703.   if (count < 0)
  2704.     return 0;    /* Nothing to do. */
  2705.  
  2706.   while (count)
  2707.     {
  2708.       if (rl_do_undo ())
  2709.     count--;
  2710.       else
  2711.     {
  2712.       ding ();
  2713.       break;
  2714.     }
  2715.     }
  2716.   return 0;
  2717. }
  2718.  
  2719. /* **************************************************************** */
  2720. /*                                    */
  2721. /*            History Utilities                */
  2722. /*                                    */
  2723. /* **************************************************************** */
  2724.  
  2725. /* We already have a history library, and that is what we use to control
  2726.    the history features of readline.  However, this is our local interface
  2727.    to the history mechanism. */
  2728.  
  2729. /* While we are editing the history, this is the saved
  2730.    version of the original line. */
  2731. HIST_ENTRY *saved_line_for_history = (HIST_ENTRY *)NULL;
  2732.  
  2733. /* Set the history pointer back to the last entry in the history. */
  2734. static void
  2735. start_using_history ()
  2736. {
  2737.   using_history ();
  2738.   if (saved_line_for_history)
  2739.     _rl_free_history_entry (saved_line_for_history);
  2740.  
  2741.   saved_line_for_history = (HIST_ENTRY *)NULL;
  2742. }
  2743.  
  2744. /* Free the contents (and containing structure) of a HIST_ENTRY. */
  2745. void
  2746. _rl_free_history_entry (entry)
  2747.      HIST_ENTRY *entry;
  2748. {
  2749.   if (!entry)
  2750.     return;
  2751.   if (entry->line)
  2752.     free (entry->line);
  2753.   free (entry);
  2754. }
  2755.  
  2756. /* Perhaps put back the current line if it has changed. */
  2757. maybe_replace_line ()
  2758. {
  2759.   HIST_ENTRY *temp = current_history ();
  2760.  
  2761.   /* If the current line has changed, save the changes. */
  2762.   if (temp && ((UNDO_LIST *)(temp->data) != rl_undo_list))
  2763.     {
  2764.       temp = replace_history_entry (where_history (), the_line, rl_undo_list);
  2765.       free (temp->line);
  2766.       free (temp);
  2767.     }
  2768.   return 0;
  2769. }
  2770.  
  2771. /* Put back the saved_line_for_history if there is one. */
  2772. maybe_unsave_line ()
  2773. {
  2774.   if (saved_line_for_history)
  2775.     {
  2776.       int line_len;
  2777.  
  2778.       line_len = strlen (saved_line_for_history->line);
  2779.  
  2780.       if (line_len >= rl_line_buffer_len)
  2781.     rl_extend_line_buffer (line_len);
  2782.  
  2783.       strcpy (the_line, saved_line_for_history->line);
  2784.       rl_undo_list = (UNDO_LIST *)saved_line_for_history->data;
  2785.       _rl_free_history_entry (saved_line_for_history);
  2786.       saved_line_for_history = (HIST_ENTRY *)NULL;
  2787.       rl_end = rl_point = strlen (the_line);
  2788.     }
  2789.   else
  2790.     ding ();
  2791.   return 0;
  2792. }
  2793.  
  2794. /* Save the current line in saved_line_for_history. */
  2795. maybe_save_line ()
  2796. {
  2797.   if (!saved_line_for_history)
  2798.     {
  2799.       saved_line_for_history = (HIST_ENTRY *)xmalloc (sizeof (HIST_ENTRY));
  2800.       saved_line_for_history->line = savestring (the_line);
  2801.       saved_line_for_history->data = (char *)rl_undo_list;
  2802.     }
  2803.   return 0;
  2804. }
  2805.  
  2806. /* **************************************************************** */
  2807. /*                                    */
  2808. /*            History Commands                */
  2809. /*                                    */
  2810. /* **************************************************************** */
  2811.  
  2812. /* Meta-< goes to the start of the history. */
  2813. rl_beginning_of_history (count, key)
  2814.      int count, key;
  2815. {
  2816.   return (rl_get_previous_history (1 + where_history ()));
  2817. }
  2818.  
  2819. /* Meta-> goes to the end of the history.  (The current line). */
  2820. rl_end_of_history (count, key)
  2821.      int count, key;
  2822. {
  2823.   maybe_replace_line ();
  2824.   using_history ();
  2825.   maybe_unsave_line ();
  2826.   return 0;
  2827. }
  2828.  
  2829. /* Move down to the next history line. */
  2830. rl_get_next_history (count, key)
  2831.      int count, key;
  2832. {
  2833.   HIST_ENTRY *temp = (HIST_ENTRY *)NULL;
  2834.  
  2835.   if (count < 0)
  2836.     return (rl_get_previous_history (-count));
  2837.  
  2838.   if (!count)
  2839.     return 0;
  2840.  
  2841.   maybe_replace_line ();
  2842.  
  2843.   while (count)
  2844.     {
  2845.       temp = next_history ();
  2846.       if (!temp)
  2847.     break;
  2848.       --count;
  2849.     }
  2850.  
  2851.   if (!temp)
  2852.     maybe_unsave_line ();
  2853.   else
  2854.     {
  2855.       int line_len;
  2856.  
  2857.       line_len = strlen (temp->line);
  2858.  
  2859.       if (line_len >= rl_line_buffer_len)
  2860.     rl_extend_line_buffer (line_len);
  2861.  
  2862.       strcpy (the_line, temp->line);
  2863.       rl_undo_list = (UNDO_LIST *)temp->data;
  2864.       rl_end = rl_point = strlen (the_line);
  2865. #if defined (VI_MODE)
  2866.       if (rl_editing_mode == vi_mode)
  2867.     rl_point = 0;
  2868. #endif /* VI_MODE */
  2869.     }
  2870.   return 0;
  2871. }
  2872.  
  2873. /* Get the previous item out of our interactive history, making it the current
  2874.    line.  If there is no previous history, just ding. */
  2875. rl_get_previous_history (count, key)
  2876.      int count, key;
  2877. {
  2878.   HIST_ENTRY *old_temp = (HIST_ENTRY *)NULL;
  2879.   HIST_ENTRY *temp = (HIST_ENTRY *)NULL;
  2880.  
  2881.   if (count < 0)
  2882.     return (rl_get_next_history (-count));
  2883.  
  2884.   if (!count)
  2885.     return 0;
  2886.  
  2887.   /* If we don't have a line saved, then save this one. */
  2888.   maybe_save_line ();
  2889.  
  2890.   /* If the current line has changed, save the changes. */
  2891.   maybe_replace_line ();
  2892.  
  2893.   while (count)
  2894.     {
  2895.       temp = previous_history ();
  2896.       if (!temp)
  2897.     break;
  2898.       else
  2899.     old_temp = temp;
  2900.       --count;
  2901.     }
  2902.  
  2903.   /* If there was a large argument, and we moved back to the start of the
  2904.      history, that is not an error.  So use the last value found. */
  2905.   if (!temp && old_temp)
  2906.     temp = old_temp;
  2907.  
  2908.   if (!temp)
  2909.     ding ();
  2910.   else
  2911.     {
  2912.       int line_len;
  2913.  
  2914.       line_len = strlen (temp->line);
  2915.  
  2916.       if (line_len >= rl_line_buffer_len)
  2917.     rl_extend_line_buffer (line_len);
  2918.  
  2919.       strcpy (the_line, temp->line);
  2920.       rl_undo_list = (UNDO_LIST *)temp->data;
  2921.       rl_end = rl_point = line_len;
  2922.  
  2923. #if defined (VI_MODE)
  2924.       if (rl_editing_mode == vi_mode)
  2925.     rl_point = 0;
  2926. #endif /* VI_MODE */
  2927.     }
  2928.   return 0;
  2929. }
  2930.  
  2931. /* Make C be the next command to be executed. */
  2932. rl_execute_next (c)
  2933.      int c;
  2934. {
  2935.   rl_pending_input = c;
  2936.   return 0;
  2937. }
  2938.  
  2939. /* **************************************************************** */
  2940. /*                                    */
  2941. /*           The Mark and the Region.                */
  2942. /*                                    */
  2943. /* **************************************************************** */
  2944.  
  2945. /* Set the mark at POSITION. */
  2946. rl_set_mark (position)
  2947.      int position;
  2948. {
  2949.   if (position > rl_end)
  2950.     return -1;
  2951.  
  2952.   rl_mark = position;
  2953.   return 0;
  2954. }
  2955.  
  2956. /* Exchange the position of mark and point. */
  2957. rl_exchange_mark_and_point (count, key)
  2958.      int count, key;
  2959. {
  2960.   if (rl_mark > rl_end)
  2961.     rl_mark = -1;
  2962.  
  2963.   if (rl_mark == -1)
  2964.     {
  2965.       ding ();
  2966.       return -1;
  2967.     }
  2968.   else
  2969.     {
  2970.       int temp = rl_point;
  2971.  
  2972.       rl_point = rl_mark;
  2973.       rl_mark = temp;
  2974.     }
  2975.   return 0;
  2976. }
  2977.  
  2978.  
  2979. /* **************************************************************** */
  2980. /*                                    */
  2981. /*            Killing Mechanism                */
  2982. /*                                    */
  2983. /* **************************************************************** */
  2984.  
  2985. /* What we assume for a max number of kills. */
  2986. #define DEFAULT_MAX_KILLS 10
  2987.  
  2988. /* The real variable to look at to find out when to flush kills. */
  2989. int rl_max_kills =  DEFAULT_MAX_KILLS;
  2990.  
  2991. /* Where to store killed text. */
  2992. char **rl_kill_ring = (char **)NULL;
  2993.  
  2994. /* Where we are in the kill ring. */
  2995. int rl_kill_index = 0;
  2996.  
  2997. /* How many slots we have in the kill ring. */
  2998. int rl_kill_ring_length = 0;
  2999.  
  3000. /* How to say that you only want to save a certain amount
  3001.    of kill material. */
  3002. rl_set_retained_kills (num)
  3003.      int num;
  3004. {
  3005.   return 0;
  3006. }
  3007.  
  3008. /* The way to kill something.  This appends or prepends to the last
  3009.    kill, if the last command was a kill command.  if FROM is less
  3010.    than TO, then the text is appended, otherwise prepended.  If the
  3011.    last command was not a kill command, then a new slot is made for
  3012.    this kill. */
  3013. rl_kill_text (from, to)
  3014.      int from, to;
  3015. {
  3016.   int slot;
  3017.   char *text;
  3018.  
  3019.   /* Is there anything to kill? */
  3020.   if (from == to)
  3021.     {
  3022.       last_command_was_kill++;
  3023.       return 0;
  3024.     }
  3025.  
  3026.   text = rl_copy_text (from, to);
  3027.  
  3028.   /* Delete the copied text from the line. */
  3029.   rl_delete_text (from, to);
  3030.  
  3031.   /* First, find the slot to work with. */
  3032.   if (!last_command_was_kill)
  3033.     {
  3034.       /* Get a new slot.  */
  3035.       if (!rl_kill_ring)
  3036.     {
  3037.       /* If we don't have any defined, then make one. */
  3038.       rl_kill_ring = (char **)
  3039.         xmalloc (((rl_kill_ring_length = 1) + 1) * sizeof (char *));
  3040.       rl_kill_ring[slot = 0] = (char *)NULL;
  3041.     }
  3042.       else
  3043.     {
  3044.       /* We have to add a new slot on the end, unless we have
  3045.          exceeded the max limit for remembering kills. */
  3046.       slot = rl_kill_ring_length;
  3047.       if (slot == rl_max_kills)
  3048.         {
  3049.           register int i;
  3050.           free (rl_kill_ring[0]);
  3051.           for (i = 0; i < slot; i++)
  3052.         rl_kill_ring[i] = rl_kill_ring[i + 1];
  3053.         }
  3054.       else
  3055.         {
  3056.           slot = rl_kill_ring_length += 1;
  3057.           rl_kill_ring = (char **)xrealloc (rl_kill_ring, slot * sizeof (char *));
  3058.         }
  3059.       rl_kill_ring[--slot] = (char *)NULL;
  3060.     }
  3061.     }
  3062.   else
  3063.     slot = rl_kill_ring_length - 1;
  3064.  
  3065.   /* If the last command was a kill, prepend or append. */
  3066.   if (last_command_was_kill && rl_editing_mode != vi_mode)
  3067.     {
  3068.       char *old = rl_kill_ring[slot];
  3069.       char *new = xmalloc (1 + strlen (old) + strlen (text));
  3070.  
  3071.       if (from < to)
  3072.     {
  3073.       strcpy (new, old);
  3074.       strcat (new, text);
  3075.     }
  3076.       else
  3077.     {
  3078.       strcpy (new, text);
  3079.       strcat (new, old);
  3080.     }
  3081.       free (old);
  3082.       free (text);
  3083.       rl_kill_ring[slot] = new;
  3084.     }
  3085.   else
  3086.     {
  3087.       rl_kill_ring[slot] = text;
  3088.     }
  3089.   rl_kill_index = slot;
  3090.   last_command_was_kill++;
  3091.   return 0;
  3092. }
  3093.  
  3094. /* Now REMEMBER!  In order to do prepending or appending correctly, kill
  3095.    commands always make rl_point's original position be the FROM argument,
  3096.    and rl_point's extent be the TO argument. */
  3097.  
  3098. /* **************************************************************** */
  3099. /*                                    */
  3100. /*            Killing Commands                */
  3101. /*                                    */
  3102. /* **************************************************************** */
  3103.  
  3104. /* Delete the word at point, saving the text in the kill ring. */
  3105. rl_kill_word (count, key)
  3106.      int count, key;
  3107. {
  3108.   int orig_point = rl_point;
  3109.  
  3110.   if (count < 0)
  3111.     return (rl_backward_kill_word (-count));
  3112.   else
  3113.     {
  3114.       rl_forward_word (count);
  3115.  
  3116.       if (rl_point != orig_point)
  3117.     rl_kill_text (orig_point, rl_point);
  3118.  
  3119.       rl_point = orig_point;
  3120.     }
  3121.   return 0;
  3122. }
  3123.  
  3124. /* Rubout the word before point, placing it on the kill ring. */
  3125. rl_backward_kill_word (count, ignore)
  3126.      int count, ignore;
  3127. {
  3128.   int orig_point = rl_point;
  3129.  
  3130.   if (count < 0)
  3131.     return (rl_kill_word (-count));
  3132.   else
  3133.     {
  3134.       rl_backward_word (count);
  3135.  
  3136.       if (rl_point != orig_point)
  3137.     rl_kill_text (orig_point, rl_point);
  3138.     }
  3139.   return 0;
  3140. }
  3141.  
  3142. /* Kill from here to the end of the line.  If DIRECTION is negative, kill
  3143.    back to the line start instead. */
  3144. rl_kill_line (direction, ignore)
  3145.      int direction, ignore;
  3146. {
  3147.   int orig_point = rl_point;
  3148.  
  3149.   if (direction < 0)
  3150.     return (rl_backward_kill_line (1));
  3151.   else
  3152.     {
  3153.       rl_end_of_line (1, ignore);
  3154.       if (orig_point != rl_point)
  3155.     rl_kill_text (orig_point, rl_point);
  3156.       rl_point = orig_point;
  3157.     }
  3158.   return 0;
  3159. }
  3160.  
  3161. /* Kill backwards to the start of the line.  If DIRECTION is negative, kill
  3162.    forwards to the line end instead. */
  3163. rl_backward_kill_line (direction, ignore)
  3164.      int direction, ignore;
  3165. {
  3166.   int orig_point = rl_point;
  3167.  
  3168.   if (direction < 0)
  3169.     return (rl_kill_line (1));
  3170.   else
  3171.     {
  3172.       if (!rl_point)
  3173.     ding ();
  3174.       else
  3175.     {
  3176.       rl_beg_of_line (1, ignore);
  3177.       rl_kill_text (orig_point, rl_point);
  3178.     }
  3179.     }
  3180.   return 0;
  3181. }
  3182.  
  3183. /* Kill the whole line, no matter where point is. */
  3184. rl_kill_full_line (count, ignore)
  3185.      int count, ignore;
  3186. {
  3187.   rl_begin_undo_group ();
  3188.   rl_point = 0;
  3189.   rl_kill_text (rl_point, rl_end);
  3190.   rl_end_undo_group ();
  3191.   return 0;
  3192. }
  3193.  
  3194. /* Yank back the last killed text.  This ignores arguments. */
  3195. rl_yank (count, ignore)
  3196.      int count, ignore;
  3197. {
  3198.   if (!rl_kill_ring)
  3199.     {
  3200.       rl_abort (count, ignore);
  3201.       return -1;
  3202.     }
  3203.  
  3204.   rl_set_mark (rl_point);
  3205.   rl_insert_text (rl_kill_ring[rl_kill_index]);
  3206.   return 0;
  3207. }
  3208.  
  3209. /* If the last command was yank, or yank_pop, and the text just
  3210.    before point is identical to the current kill item, then
  3211.    delete that text from the line, rotate the index down, and
  3212.    yank back some other text. */
  3213. rl_yank_pop (count, key)
  3214.      int count, key;
  3215. {
  3216.   int l;
  3217.  
  3218.   if (((rl_last_func != rl_yank_pop) && (rl_last_func != rl_yank)) ||
  3219.       !rl_kill_ring)
  3220.     {
  3221.       rl_abort (1, key);
  3222.       return -1;
  3223.     }
  3224.  
  3225.   l = strlen (rl_kill_ring[rl_kill_index]);
  3226.   if (((rl_point - l) >= 0) &&
  3227.       (strncmp (the_line + (rl_point - l),
  3228.         rl_kill_ring[rl_kill_index], l) == 0))
  3229.     {
  3230.       rl_delete_text ((rl_point - l), rl_point);
  3231.       rl_point -= l;
  3232.       rl_kill_index--;
  3233.       if (rl_kill_index < 0)
  3234.     rl_kill_index = rl_kill_ring_length - 1;
  3235.       rl_yank (1, 0);
  3236.       return 0;
  3237.     }
  3238.   else
  3239.     {
  3240.       rl_abort (1, key);
  3241.       return -1;
  3242.     }
  3243. }
  3244.  
  3245. /* Yank the COUNTth argument from the previous history line. */
  3246. rl_yank_nth_arg (count, ignore)
  3247.      int count, ignore;
  3248. {
  3249.   register HIST_ENTRY *entry = previous_history ();
  3250.   char *arg;
  3251.  
  3252.   if (entry)
  3253.     next_history ();
  3254.   else
  3255.     {
  3256.       ding ();
  3257.       return -1;
  3258.     }
  3259.  
  3260.   arg = history_arg_extract (count, count, entry->line);
  3261.   if (!arg || !*arg)
  3262.     {
  3263.       ding ();
  3264.       return -1;
  3265.     }
  3266.  
  3267.   rl_begin_undo_group ();
  3268.  
  3269. #if defined (VI_MODE)
  3270.   /* Vi mode always inserts a space before yanking the argument, and it
  3271.      inserts it right *after* rl_point. */
  3272.   if (rl_editing_mode == vi_mode)
  3273.     {
  3274.       rl_vi_append_mode ();
  3275.       rl_insert_text (" ");
  3276.     }
  3277. #endif /* VI_MODE */
  3278.  
  3279.   rl_insert_text (arg);
  3280.   free (arg);
  3281.  
  3282.   rl_end_undo_group ();
  3283.   return 0;
  3284. }
  3285.  
  3286. /* Yank the last argument from the previous history line.  This `knows'
  3287.    how rl_yank_nth_arg treats a count of `$'.  With an argument, this
  3288.    behaves the same as rl_yank_nth_arg. */
  3289. int
  3290. rl_yank_last_arg (count, key)
  3291.      int count, key;
  3292. {
  3293.   if (rl_explicit_arg)
  3294.     return (rl_yank_nth_arg (count, key));
  3295.   else
  3296.     return (rl_yank_nth_arg ('$', key));
  3297. }
  3298.  
  3299. /* How to toggle back and forth between editing modes. */
  3300. rl_vi_editing_mode (count, key)
  3301.      int count, key;
  3302. {
  3303. #if defined (VI_MODE)
  3304.   rl_editing_mode = vi_mode;
  3305.   rl_vi_insertion_mode ();
  3306.   return 0;
  3307. #endif /* VI_MODE */
  3308. }
  3309.  
  3310. rl_emacs_editing_mode (count, key)
  3311.      int count, key;
  3312. {
  3313.   rl_editing_mode = emacs_mode;
  3314.   _rl_keymap = emacs_standard_keymap;
  3315.   return 0;
  3316. }
  3317.  
  3318.  
  3319. /* **************************************************************** */
  3320. /*                                    */
  3321. /*            USG (System V) Support                */
  3322. /*                                    */
  3323. /* **************************************************************** */
  3324.  
  3325. int
  3326. rl_getc (stream)
  3327.      FILE *stream;
  3328. {
  3329.   int result;
  3330.   unsigned char c;
  3331.  
  3332. #if defined (__GO32__)
  3333.   if (isatty (0))
  3334.     return (getkey () & 0x7F);
  3335. #endif /* __GO32__ */
  3336.  
  3337.   while (1)
  3338.     {
  3339.       result = read (fileno (stream), &c, sizeof (unsigned char));
  3340.  
  3341.       if (result == sizeof (unsigned char))
  3342.     return (c);
  3343.  
  3344.       /* If zero characters are returned, then the file that we are
  3345.      reading from is empty!  Return EOF in that case. */
  3346.       if (result == 0)
  3347.     return (EOF);
  3348.  
  3349. #if defined (EWOULDBLOCK)
  3350.       if (errno == EWOULDBLOCK)
  3351.     {
  3352.       int flags;
  3353.  
  3354.       if ((flags = fcntl (fileno (stream), F_GETFL, 0)) < 0)
  3355.         return (EOF);
  3356.       if (flags & O_NDELAY)
  3357.         {
  3358.           flags &= ~O_NDELAY;
  3359.           fcntl (fileno (stream), F_SETFL, flags);
  3360.           continue;
  3361.         }
  3362.       continue;
  3363.     }
  3364. #endif /* EWOULDBLOCK */
  3365.  
  3366. #if defined (_POSIX_VERSION) && defined (EAGAIN) && defined (O_NONBLOCK)
  3367.       if (errno == EAGAIN)
  3368.     {
  3369.       int flags;
  3370.  
  3371.       if ((flags = fcntl (fileno (stream), F_GETFL, 0)) < 0)
  3372.         return (EOF);
  3373.       if (flags & O_NONBLOCK)
  3374.         {
  3375.           flags &= ~O_NONBLOCK;
  3376.           fcntl (fileno (stream), F_SETFL, flags);
  3377.           continue;
  3378.         }
  3379.     }
  3380. #endif /* _POSIX_VERSION && EAGAIN && O_NONBLOCK */
  3381.  
  3382. #if !defined (__GO32__)
  3383.       /* If the error that we received was SIGINT, then try again,
  3384.      this is simply an interrupted system call to read ().
  3385.      Otherwise, some error ocurred, also signifying EOF. */
  3386.       if (errno != EINTR)
  3387.     return (EOF);
  3388. #endif /* !__GO32__ */
  3389.     }
  3390. }
  3391.  
  3392. #if !defined (SHELL)
  3393. #ifdef savestring
  3394. #undef savestring
  3395. #endif
  3396. /* Backwards compatibilty, now that savestring has been removed from
  3397.    all `public' readline header files. */
  3398. char *
  3399. savestring (s)
  3400.      char *s;
  3401. {
  3402.   return ((char *)strcpy (xmalloc (1 + (int)strlen (s)), (s)));
  3403. }
  3404. #endif
  3405.  
  3406. /* Function equivalents for the macros defined in chartypes.h. */
  3407. #undef uppercase_p
  3408. int
  3409. uppercase_p (c)
  3410.      int c;
  3411. {
  3412.   return (isupper (c));
  3413. }
  3414.  
  3415. #undef lowercase_p
  3416. int
  3417. lowercase_p (c)
  3418.      int c;
  3419. {
  3420.   return (islower (c));
  3421. }
  3422.  
  3423. #undef pure_alphabetic
  3424. int
  3425. pure_alphabetic (c)
  3426.      int c;
  3427. {
  3428.   return (isupper (c) || islower (c));
  3429. }
  3430.  
  3431. #undef digit_p
  3432. int
  3433. digit_p (c)
  3434.      int c;
  3435. {
  3436.   return (isdigit (c));
  3437. }
  3438.  
  3439. #undef to_lower
  3440. int
  3441. to_lower (c)
  3442.      int c;
  3443. {
  3444.   return (isupper (c) ? tolower (c) : c);
  3445. }
  3446.  
  3447. #undef to_upper
  3448. int
  3449. to_upper (c)
  3450.      int c;
  3451. {
  3452.   return (islower (c) ? toupper (c) : c);
  3453. }
  3454.  
  3455. #undef digit_value
  3456. int
  3457. digit_value (c)
  3458.      int c;
  3459. {
  3460.   return (isdigit (c) ? c - '0' : c);
  3461. }
  3462.  
  3463. #if defined (__EMX__) && defined (OS2)
  3464. char *
  3465. _rl_savestring (str)
  3466.      char *str;
  3467. {
  3468.   char *copy = (char*) xmalloc (strlen (str) + 1);
  3469.   strcpy (copy, str);
  3470.   return copy;
  3471. }
  3472. #endif
  3473.  
  3474. #if defined (STATIC_MALLOC)
  3475.  
  3476. /* **************************************************************** */
  3477. /*                                    */
  3478. /*            xmalloc and xrealloc ()                     */
  3479. /*                                    */
  3480. /* **************************************************************** */
  3481.  
  3482. static void memory_error_and_abort ();
  3483.  
  3484. static char *
  3485. xmalloc (bytes)
  3486.      int bytes;
  3487. {
  3488.   char *temp = (char *)malloc (bytes);
  3489.  
  3490.   if (!temp)
  3491.     memory_error_and_abort ();
  3492.   return (temp);
  3493. }
  3494.  
  3495. static char *
  3496. xrealloc (pointer, bytes)
  3497.      char *pointer;
  3498.      int bytes;
  3499. {
  3500.   char *temp;
  3501.  
  3502.   if (!pointer)
  3503.     temp = (char *)malloc (bytes);
  3504.   else
  3505.     temp = (char *)realloc (pointer, bytes);
  3506.  
  3507.   if (!temp)
  3508.     memory_error_and_abort ();
  3509.  
  3510.   return (temp);
  3511. }
  3512.  
  3513. static void
  3514. memory_error_and_abort ()
  3515. {
  3516.   fprintf (stderr, "readline: Out of virtual memory!\n");
  3517.   abort ();
  3518. }
  3519. #endif /* STATIC_MALLOC */
  3520.  
  3521.  
  3522. /* **************************************************************** */
  3523. /*                                    */
  3524. /*            Testing Readline                */
  3525. /*                                    */
  3526. /* **************************************************************** */
  3527.  
  3528. #if defined (TEST)
  3529.  
  3530. main ()
  3531. {
  3532.   HIST_ENTRY **history_list ();
  3533.   char *temp = (char *)NULL;
  3534.   char *prompt = "readline% ";
  3535.   int done = 0;
  3536.  
  3537.   while (!done)
  3538.     {
  3539.       temp = readline (prompt);
  3540.  
  3541.       /* Test for EOF. */
  3542.       if (!temp)
  3543.     exit (1);
  3544.  
  3545.       /* If there is anything on the line, print it and remember it. */
  3546.       if (*temp)
  3547.     {
  3548.       fprintf (stderr, "%s\r\n", temp);
  3549.       add_history (temp);
  3550.     }
  3551.  
  3552.       /* Check for `command' that we handle. */
  3553.       if (strcmp (temp, "quit") == 0)
  3554.     done = 1;
  3555.  
  3556.       if (strcmp (temp, "list") == 0)
  3557.     {
  3558.       HIST_ENTRY **list = history_list ();
  3559.       register int i;
  3560.       if (list)
  3561.         {
  3562.           for (i = 0; list[i]; i++)
  3563.         {
  3564.           fprintf (stderr, "%d: %s\r\n", i, list[i]->line);
  3565.           free (list[i]->line);
  3566.         }
  3567.           free (list);
  3568.         }
  3569.     }
  3570.       free (temp);
  3571.     }
  3572. }
  3573.  
  3574. #endif /* TEST */
  3575.  
  3576.  
  3577. /*
  3578.  * Local variables:
  3579.  * compile-command: "gcc -g -traditional -I. -I.. -DTEST -o readline readline.c keymaps.o funmap.o history.o -ltermcap"
  3580.  * end:
  3581.  */
  3582.